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  * director_common.swg
 320  *
 321  * This file contains support for director classes which is common between
 322  * languages.
 323  * ----------------------------------------------------------------------------- */
 324
 325 /*
 326   Use -DSWIG_DIRECTOR_STATIC if you prefer to avoid the use of the
 327   'Swig' namespace. This could be useful for multi-modules projects.
 328 */
 329 #ifdef SWIG_DIRECTOR_STATIC
 330 /* Force anonymous (static) namespace */
 331 #define Swig
 332 #endif
 333 /* -----------------------------------------------------------------------------
 334  * director.swg
 335  *
 336  * This file contains support for director classes so that C# proxy
 337  * methods can be called from C++.
 338  * ----------------------------------------------------------------------------- */
 339
 340 #if defined(DEBUG_DIRECTOR_OWNED)
 341 #include <iostream>
 342 #endif
 343 #include <string>
 344 #include <exception>
 345
 346 namespace Swig {
 347   /* Director base class - not currently used in C# directors */
 348   class Director {
 349   };
 350
 351   /* Base class for director exceptions */
 352   class DirectorException : public std::exception {
 353   protected:
 354     std::string swig_msg;
 355
 356   public:
 357     DirectorException(const char *msg) : swig_msg(msg) {
 358     }
 359
 360     DirectorException(const std::string &msg) : swig_msg(msg) {
 361     }
 362
 363     virtual ~DirectorException() throw() {
 364     }
 365
 366     const char *what() const throw() {
 367       return swig_msg.c_str();
 368     }
 369   };
 370
 371   /* Pure virtual method exception */
 372   class DirectorPureVirtualException : public DirectorException {
 373   public:
 374     DirectorPureVirtualException(const char *msg) : DirectorException(std::string("Attempt to invoke pure virtual method ") + msg) {
 375     }
 376   };
 377 }
 378
 379
 380 void SWIG_CSharpException(int code, const char *msg) {
 381   if (code == SWIG_ValueError) {
 382     SWIG_CSharpExceptionArgumentCodes exception_code = SWIG_CSharpArgumentOutOfRangeException;
 383     SWIG_CSharpSetPendingExceptionArgument(exception_code, msg, 0);
 384   } else {
 385     SWIG_CSharpExceptionCodes exception_code = SWIG_CSharpApplicationException;
 386     switch(code) {
 387     case SWIG_MemoryError:
 388       exception_code = SWIG_CSharpOutOfMemoryException;
 389       break;
 390     case SWIG_IndexError:
 391       exception_code = SWIG_CSharpIndexOutOfRangeException;
 392       break;
 393     case SWIG_DivisionByZero:
 394       exception_code = SWIG_CSharpDivideByZeroException;
 395       break;
 396     case SWIG_IOError:
 397       exception_code = SWIG_CSharpIOException;
 398       break;
 399     case SWIG_OverflowError:
 400       exception_code = SWIG_CSharpOverflowException;
 401       break;
 402     case SWIG_RuntimeError:
 403     case SWIG_TypeError:
 404     case SWIG_SyntaxError:
 405     case SWIG_SystemError:
 406     case SWIG_UnknownError:
 407     default:
 408       exception_code = SWIG_CSharpApplicationException;
 409       break;
 410     }
 411     SWIG_CSharpSetPendingException(exception_code, msg);
 412   }
 413 }
 414
 415
 416 #include <stdexcept>
 417
 418
 419 #define SWIGSTDCALL
 420
 421 #include <time.h>
 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 #include <dali/devel-api/events/touch-point.h>
 432
 433 #include <dali/public-api/math/matrix.h>
 434 #include <dali/public-api/math/matrix3.h>
 435 #include <dali/public-api/math/viewport.h>
 436 #include <dali/public-api/object/property-key.h>
 437 #include <dali/devel-api/object/csharp-type-info.h>
 438 #include <dali/devel-api/object/csharp-type-registry.h>
 439
 440 #include <dali/public-api/adaptor-framework/timer.h>
 441 #include <dali/public-api/adaptor-framework/style-change.h>
 442 #include <dali/devel-api/adaptor-framework/environment-variable.h>
 443
 444 #include <dali-toolkit/devel-api/accessibility-manager/accessibility-manager.h>
 445
 446 #include <dali-toolkit/devel-api/builder/builder.h>
 447
 448 #include <dali-toolkit/devel-api/focus-manager/keyinput-focus-manager.h>
 449 #include <dali-toolkit/devel-api/focus-manager/keyboard-focus-manager-devel.h>
 450
 451 #include <dali-toolkit/devel-api/controls/control-devel.h>
 452 #include <dali-toolkit/devel-api/controls/popup/popup.h>
 453 #include <dali-toolkit/devel-api/controls/gaussian-blur-view/gaussian-blur-view.h>
 454 #include <dali-toolkit/devel-api/controls/page-turn-view/page-factory.h>
 455 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-view.h>
 456 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-landscape-view.h>
 457 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-portrait-view.h>
 458 #include <dali-toolkit/devel-api/controls/buttons/toggle-button.h>
 459 #include <dali-toolkit/devel-api/controls/alignment/alignment.h>
 460 #include <dali-toolkit/devel-api/controls/scroll-bar/scroll-bar.h>
 461 #include <dali-toolkit/devel-api/controls/table-view/table-view.h>
 462
 463 #include <dali-toolkit/devel-api/visual-factory/visual-base.h>
 464 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
 465 #include <dali-toolkit/devel-api/visual-factory/transition-data.h>
 466
 467 #include <dali-toolkit/public-api/visuals/visual-properties.h>
 468 #include <dali-toolkit/public-api/visuals/text-visual-properties.h>
 469 #include <dali-toolkit/public-api/visuals/image-visual-properties.h>
 470
 471 #include <dali-toolkit/devel-api/controls/tooltip/tooltip-properties.h>
 472 #include <dali-toolkit/devel-api/visuals/image-visual-properties-devel.h>
 473 #include <dali-toolkit/devel-api/controls/control-depth-index-ranges.h>
 474
 475 #include <dali-toolkit/public-api/controls/scrollable/item-view/item-view-declarations.h>
 476
 477 #include <dali/devel-api/adaptor-framework/pixel-buffer.h>
 478 #include <dali/devel-api/adaptor-framework/image-loading.h>
 479
 480 #include <dali/public-api/events/mouse-button.h>
 481
 482 #include <dali-toolkit/devel-api/controls/web-view/web-view.h>
 483 #include "web-view-signal-converter.h"
 484
 485 #include <dali/integration-api/debug.h>
 486
 487 #include <dali-toolkit/devel-api/controls/video-view/video-view-devel.h>
 488
 489 #include <dali/devel-api/adaptor-framework/native-image-source-devel.h>
 490
 491 #include <dali-toolkit/devel-api/text/rendering-backend.h>
 492
 493
 494 #include <dali/devel-api/update/frame-callback-interface.h>
 495 #include <dali/devel-api/update/update-proxy.h>
 496
 497
 498 // add here SWIG version check
 499
 500 #if defined(_MSC_VER)         // Microsoft Visual C++ 6.0
 501 // disable Swig-dependent warnings
 502
 503 // 'identifier1' has C-linkage specified,
 504 // but returns UDT 'identifier2' which is incompatible with C
 505 #pragma warning(disable: 4190)
 506
 507 // 'int' : forcing value to bool 'true' or 'false' (performance warning)
 508 #pragma warning(disable: 4800)
 509
 510 // debug info too long etc etc
 511 #pragma warning(disable: 4786)
 512 #endif
 513
 514
 515 #include <stdexcept>
 516
 517
 518 #include <string>
 519
 520
 521 #include <vector>
 522 #include <algorithm>
 523 #include <stdexcept>
 524
 525
 526 #include <map>
 527 #include <algorithm>
 528 #include <stdexcept>
 529
 530
 531 #include <utility>
 532
 533
 534 typedef float floatp;
 535
 536 SWIGINTERN floatp *new_floatp(){
 537   return new float();
 538 }
 539 SWIGINTERN void delete_floatp(floatp *self){
 540   if (self) delete self;
 541 }
 542 SWIGINTERN void floatp_assign(floatp *self,float value){
 543   *self = value;
 544 }
 545 SWIGINTERN float floatp_value(floatp *self){
 546   return *self;
 547 }
 548 SWIGINTERN float *floatp_cast(floatp *self){
 549   return self;
 550 }
 551 SWIGINTERN floatp *floatp_frompointer(float *t){
 552   return (floatp *) t;
 553 }
 554
 555 typedef int intp;
 556
 557 SWIGINTERN intp *new_intp(){
 558   return new int();
 559 }
 560 SWIGINTERN void delete_intp(intp *self){
 561   if (self) delete self;
 562 }
 563 SWIGINTERN void intp_assign(intp *self,int value){
 564   *self = value;
 565 }
 566 SWIGINTERN int intp_value(intp *self){
 567   return *self;
 568 }
 569 SWIGINTERN int *intp_cast(intp *self){
 570   return self;
 571 }
 572 SWIGINTERN intp *intp_frompointer(int *t){
 573   return (intp *) t;
 574 }
 575
 576 typedef double doublep;
 577
 578 SWIGINTERN doublep *new_doublep(){
 579   return new double();
 580 }
 581 SWIGINTERN void delete_doublep(doublep *self){
 582   if (self) delete self;
 583 }
 584 SWIGINTERN void doublep_assign(doublep *self,double value){
 585   *self = value;
 586 }
 587 SWIGINTERN double doublep_value(doublep *self){
 588   return *self;
 589 }
 590 SWIGINTERN double *doublep_cast(doublep *self){
 591   return self;
 592 }
 593 SWIGINTERN doublep *doublep_frompointer(double *t){
 594   return (doublep *) t;
 595 }
 596
 597 typedef unsigned int uintp;
 598
 599 SWIGINTERN uintp *new_uintp(){
 600   return new unsigned int();
 601 }
 602 SWIGINTERN void delete_uintp(uintp *self){
 603   if (self) delete self;
 604 }
 605 SWIGINTERN void uintp_assign(uintp *self,unsigned int value){
 606   *self = value;
 607 }
 608 SWIGINTERN unsigned int uintp_value(uintp *self){
 609   return *self;
 610 }
 611 SWIGINTERN unsigned int *uintp_cast(uintp *self){
 612   return self;
 613 }
 614 SWIGINTERN uintp *uintp_frompointer(unsigned int *t){
 615   return (uintp *) t;
 616 }
 617
 618 typedef unsigned short ushortp;
 619
 620 SWIGINTERN ushortp *new_ushortp(){
 621   return new unsigned short();
 622 }
 623 SWIGINTERN void delete_ushortp(ushortp *self){
 624   if (self) delete self;
 625 }
 626 SWIGINTERN void ushortp_assign(ushortp *self,unsigned short value){
 627   *self = value;
 628 }
 629 SWIGINTERN unsigned short ushortp_value(ushortp *self){
 630   return *self;
 631 }
 632 SWIGINTERN unsigned short *ushortp_cast(ushortp *self){
 633   return self;
 634 }
 635 SWIGINTERN ushortp *ushortp_frompointer(unsigned short *t){
 636   return (ushortp *) t;
 637 }
 638
 639 unsigned int int_to_uint(int x) {
 640    return (unsigned int) x;
 641 }
 642
 643
 644 #define CALL_CATCH_EXCEPTION(ret)          \
 645          catch (std::out_of_range& e)            \
 646          {                                                                                                                                  \
 647              SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));   \
 648              return ret;\
 649           }                                                                                                                                 \
 650           catch (std::exception& e)                                                                                         \
 651           {                                                                                                                                 \
 652             SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));\
 653             return ret;\
 654           }                                                                                                                                 \
 655           catch (DaliException e)                                                                                            \
 656           {                                                                                                                                 \
 657             SWIG_CSharpException(SWIG_UnknownError, e.condition);                            \
 658             return ret;\
 659           }                                                                                                                                 \
 660           catch (...)                                                                                                                  \
 661           {                                                                                                                                 \
 662             SWIG_CSharpException(SWIG_UnknownError, "unknown error");                  \
 663             return ret;\
 664           }
 665
 666
 667
 668 using namespace Dali;
 669 using namespace Dali::Toolkit;
 670
 671 SWIGINTERN bool Dali_BaseHandle_HasBody(Dali::BaseHandle const *self)
 672 {
 673   bool result = false;
 674   try
 675   {
 676     // C++ code. DALi uses Handle <-> Body design pattern.
 677     // This function checks the Handle to see if it has a body attached ( possible to have empty handles).
 678     // Handles in DALi can be converted into a boolean type
 679     // to check if the handle has a valid body attached to it.
 680     // Internally checking *self will  checks IntrusivePtr<Dali::RefObject> mObjectHandle in BaseHandle;
 681     if( *self )
 682     {
 683       result = true;
 684     }
 685     else
 686     {
 687       result = false;
 688     }
 689   }
 690   CALL_CATCH_EXCEPTION(false);
 691   return result;
 692 }
 693
 694 SWIGINTERN bool Dali_BaseHandle_IsEqual(Dali::BaseHandle const *self,Dali::BaseHandle const &rhs)
 695 {
 696   bool result = false;
 697   try
 698   {
 699     // C++ code. Check if two handles reference the same implemtion
 700     if( *self == rhs)
 701     {
 702       result = true;
 703     }
 704     else
 705     {
 706       result = false;
 707     }
 708   }
 709   CALL_CATCH_EXCEPTION(false);
 710   return result;
 711 }
 712
 713
 714 SWIGINTERN void Dali_TypeRegistration_RegisterControl(std::string const &controlName,Dali::CSharpTypeInfo::CreateFunction createFunc){
 715      Dali::CSharpTypeRegistry::RegisterType( controlName, typeid( Dali::Toolkit::Control), createFunc );
 716    }
 717 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){
 718      Dali::CSharpTypeRegistry::RegisterProperty( controlName, propertyName, index, type, setFunc, getFunc );
 719    }
 720 SWIGINTERN std::vector< Dali::TouchPoint > *new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(int capacity){
 721         std::vector< Dali::TouchPoint >* pv = 0;
 722         if (capacity >= 0) {
 723           pv = new std::vector< Dali::TouchPoint >();
 724           pv->reserve(capacity);
 725        } else {
 726           throw std::out_of_range("capacity");
 727        }
 728        return pv;
 729       }
 730 SWIGINTERN Dali::TouchPoint std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(std::vector< Dali::TouchPoint > *self,int index){
 731         if (index>=0 && index<(int)self->size())
 732           return (*self)[index];
 733         else
 734           throw std::out_of_range("index");
 735       }
 736 SWIGINTERN Dali::TouchPoint const &std_vector_Sl_Dali_TouchPoint_Sg__getitem(std::vector< Dali::TouchPoint > *self,int index){
 737         if (index>=0 && index<(int)self->size())
 738           return (*self)[index];
 739         else
 740           throw std::out_of_range("index");
 741       }
 742 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__setitem(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &val){
 743         if (index>=0 && index<(int)self->size())
 744           (*self)[index] = val;
 745         else
 746           throw std::out_of_range("index");
 747       }
 748 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__AddRange(std::vector< Dali::TouchPoint > *self,std::vector< Dali::TouchPoint > const &values){
 749         self->insert(self->end(), values.begin(), values.end());
 750       }
 751 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__GetRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 752         if (index < 0)
 753           throw std::out_of_range("index");
 754         if (count < 0)
 755           throw std::out_of_range("count");
 756         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 757           throw std::invalid_argument("invalid range");
 758         return new std::vector< Dali::TouchPoint >(self->begin()+index, self->begin()+index+count);
 759       }
 760 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Insert(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &x){
 761         if (index>=0 && index<(int)self->size()+1)
 762           self->insert(self->begin()+index, x);
 763         else
 764           throw std::out_of_range("index");
 765       }
 766 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 767         if (index>=0 && index<(int)self->size()+1)
 768           self->insert(self->begin()+index, values.begin(), values.end());
 769         else
 770           throw std::out_of_range("index");
 771       }
 772 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(std::vector< Dali::TouchPoint > *self,int index){
 773         if (index>=0 && index<(int)self->size())
 774           self->erase(self->begin() + index);
 775         else
 776           throw std::out_of_range("index");
 777       }
 778 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 779         if (index < 0)
 780           throw std::out_of_range("index");
 781         if (count < 0)
 782           throw std::out_of_range("count");
 783         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 784           throw std::invalid_argument("invalid range");
 785         self->erase(self->begin()+index, self->begin()+index+count);
 786       }
 787 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__Repeat(Dali::TouchPoint const &value,int count){
 788         if (count < 0)
 789           throw std::out_of_range("count");
 790         return new std::vector< Dali::TouchPoint >(count, value);
 791       }
 792 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(std::vector< Dali::TouchPoint > *self){
 793         std::reverse(self->begin(), self->end());
 794       }
 795 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(std::vector< Dali::TouchPoint > *self,int index,int count){
 796         if (index < 0)
 797           throw std::out_of_range("index");
 798         if (count < 0)
 799           throw std::out_of_range("count");
 800         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 801           throw std::invalid_argument("invalid range");
 802         std::reverse(self->begin()+index, self->begin()+index+count);
 803       }
 804 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__SetRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 805         if (index < 0)
 806           throw std::out_of_range("index");
 807         if (index+values.size() > self->size())
 808           throw std::out_of_range("index");
 809         std::copy(values.begin(), values.end(), self->begin()+index);
 810       }
 811 SWIGINTERN bool Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty(Dali::Signal< void (float) > const *self){
 812          return self->Empty();
 813       }
 814 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount(Dali::Signal< void (float) > const *self){
 815         return self->GetConnectionCount();
 816       }
 817 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(Dali::Signal< void (float) > *self,void (*func)(float)){
 818           self->Connect( func );
 819       }
 820 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(Dali::Signal< void (float) > *self,void (*func)(float)){
 821           self->Disconnect( func );
 822       }
 823 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(Dali::Signal< void (float) > *self,float arg){
 824           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 825 /*@SWIG@*/ self->Emit( arg );
 826       }
 827 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty(Dali::Signal< void (Dali::BaseHandle) > const *self){
 828          return self->Empty();
 829       }
 830 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::BaseHandle) > const *self){
 831         return self->GetConnectionCount();
 832       }
 833 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 834           self->Connect( func );
 835       }
 836 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 837           self->Disconnect( func );
 838       }
 839 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(Dali::Signal< void (Dali::BaseHandle) > *self,Dali::BaseHandle arg){
 840           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 841 /*@SWIG@*/ self->Emit( arg );
 842       }
 843 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::RefObject const *) > const *self){
 844          return self->Empty();
 845       }
 846 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){
 847         return self->GetConnectionCount();
 848       }
 849 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 *)){
 850           self->Connect( func );
 851       }
 852 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 *)){
 853           self->Disconnect( func );
 854       }
 855 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){
 856           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 857 /*@SWIG@*/ self->Emit( arg );
 858       }
 859 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 860          return self->Empty();
 861       }
 862 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 863         return self->GetConnectionCount();
 864       }
 865 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 866           self->Connect( func );
 867       }
 868 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 869           self->Disconnect( func );
 870       }
 871 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(Dali::Signal< void (Dali::PropertyNotification &) > *self,Dali::PropertyNotification &arg){
 872           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 873 /*@SWIG@*/ self->Emit( arg );
 874       }
 875 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){
 876          return self->Empty();
 877       }
 878 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){
 879         return self->GetConnectionCount();
 880       }
 881 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 &)){
 882         self->Connect( func );
 883       }
 884 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 &)){
 885         self->Disconnect( func );
 886       }
 887 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){
 888         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 889 /*@SWIG@*/ self->Emit( arg1, arg2 );
 890       }
 891 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){
 892          return self->Empty();
 893       }
 894 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){
 895         return self->GetConnectionCount();
 896       }
 897 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 &)){
 898         self->Connect( func );
 899       }
 900 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 &)){
 901         self->Disconnect( func );
 902       }
 903 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){
 904         return self->Emit( arg1, arg2 );
 905       }
 906 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){
 907          return self->Empty();
 908       }
 909 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){
 910         return self->GetConnectionCount();
 911       }
 912 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 &)){
 913         self->Connect( func );
 914       }
 915 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 &)){
 916         self->Disconnect( func );
 917       }
 918 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){
 919         return self->Emit( arg1, arg2 );
 920       }
 921 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){
 922          return self->Empty();
 923       }
 924 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){
 925         return self->GetConnectionCount();
 926       }
 927 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 &)){
 928         self->Connect( func );
 929       }
 930 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 &)){
 931         self->Disconnect( func );
 932       }
 933 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){
 934         return self->Emit( arg1, arg2 );
 935       }
 936 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor) > const *self){
 937          return self->Empty();
 938       }
 939 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor) > const *self){
 940         return self->GetConnectionCount();
 941       }
 942 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 943           self->Connect( func );
 944       }
 945 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 946           self->Disconnect( func );
 947       }
 948 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor) > *self,Dali::Actor arg){
 949           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 950 /*@SWIG@*/ self->Emit( arg );
 951       }
 952 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 953          return self->Empty();
 954       }
 955 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){
 956         return self->GetConnectionCount();
 957       }
 958 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 &)){
 959           self->Connect( func );
 960       }
 961 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 &)){
 962           self->Disconnect( func );
 963       }
 964 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){
 965           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 966 /*@SWIG@*/ self->Emit( arg );
 967       }
 968 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::TouchEvent const &) > const *self){
 969          return self->Empty();
 970       }
 971 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){
 972         return self->GetConnectionCount();
 973       }
 974 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 &)){
 975           self->Connect( func );
 976       }
 977 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 &)){
 978           self->Disconnect( func );
 979       }
 980 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){
 981           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 982 /*@SWIG@*/ self->Emit( arg );
 983       }
 984 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
 985          return self->Empty();
 986       }
 987 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){
 988         return self->GetConnectionCount();
 989       }
 990 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 &)){
 991           self->Connect( func );
 992       }
 993 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 &)){
 994           self->Disconnect( func );
 995       }
 996 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){
 997           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 998 /*@SWIG@*/ self->Emit( arg );
 999       }
1000 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){
1001          return self->Empty();
1002       }
1003 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){
1004         return self->GetConnectionCount();
1005       }
1006 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 &)){
1007         self->Connect( func );
1008       }
1009 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 &)){
1010         self->Disconnect( func );
1011       }
1012 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){
1013         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1014 /*@SWIG@*/ self->Emit( arg1, arg2 );
1015       }
1016 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){
1017          return self->Empty();
1018       }
1019 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){
1020         return self->GetConnectionCount();
1021       }
1022 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 &)){
1023         self->Connect( func );
1024       }
1025 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 &)){
1026         self->Disconnect( func );
1027       }
1028 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){
1029         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1030 /*@SWIG@*/ self->Emit( arg1, arg2 );
1031       }
1032 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){
1033          return self->Empty();
1034       }
1035 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){
1036         return self->GetConnectionCount();
1037       }
1038 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 &)){
1039         self->Connect( func );
1040       }
1041 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 &)){
1042         self->Disconnect( func );
1043       }
1044 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){
1045         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1046 /*@SWIG@*/ self->Emit( arg1, arg2 );
1047       }
1048 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){
1049          return self->Empty();
1050       }
1051 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){
1052         return self->GetConnectionCount();
1053       }
1054 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)){
1055           return self->Connect( func );
1056       }
1057 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)){
1058           self->Disconnect( func );
1059       }
1060 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){
1061           self->Emit( arg1, arg3 );
1062       }
1063 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){
1064          return self->Empty();
1065       }
1066 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){
1067         return self->GetConnectionCount();
1068       }
1069 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)){
1070           return self->Connect( func );
1071       }
1072 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)){
1073           self->Disconnect( func );
1074       }
1075 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){
1076           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1077 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1078       }
1079
1080 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Empty(Dali::Signal< bool () > const *self){
1081          return self->Empty();
1082       }
1083 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount(Dali::Signal< bool () > const *self){
1084         return self->GetConnectionCount();
1085       }
1086 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(Dali::Signal< bool () > *self,bool (*func)()){
1087           self->Connect( func );
1088       }
1089 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(Dali::Signal< bool () > *self,bool (*func)()){
1090           self->Disconnect( func );
1091       }
1092 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(Dali::Signal< bool () > *self){
1093           return self->Emit();
1094       }
1095
1096 SWIGINTERN std::vector< unsigned int > *new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(int capacity){
1097         std::vector< unsigned int >* pv = 0;
1098         if (capacity >= 0) {
1099           pv = new std::vector< unsigned int >();
1100           pv->reserve(capacity);
1101        } else {
1102           throw std::out_of_range("capacity");
1103        }
1104        return pv;
1105       }
1106 SWIGINTERN unsigned int std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(std::vector< unsigned int > *self,int index){
1107         if (index>=0 && index<(int)self->size())
1108           return (*self)[index];
1109         else
1110           throw std::out_of_range("index");
1111       }
1112 SWIGINTERN unsigned int const &std_vector_Sl_unsigned_SS_int_Sg__getitem(std::vector< unsigned int > *self,int index){
1113         if (index>=0 && index<(int)self->size())
1114           return (*self)[index];
1115         else
1116           throw std::out_of_range("index");
1117       }
1118 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__setitem(std::vector< unsigned int > *self,int index,unsigned int const &val){
1119         if (index>=0 && index<(int)self->size())
1120           (*self)[index] = val;
1121         else
1122           throw std::out_of_range("index");
1123       }
1124 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__AddRange(std::vector< unsigned int > *self,std::vector< unsigned int > const &values){
1125         self->insert(self->end(), values.begin(), values.end());
1126       }
1127 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__GetRange(std::vector< unsigned int > *self,int index,int count){
1128         if (index < 0)
1129           throw std::out_of_range("index");
1130         if (count < 0)
1131           throw std::out_of_range("count");
1132         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1133           throw std::invalid_argument("invalid range");
1134         return new std::vector< unsigned int >(self->begin()+index, self->begin()+index+count);
1135       }
1136 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Insert(std::vector< unsigned int > *self,int index,unsigned int const &x){
1137         if (index>=0 && index<(int)self->size()+1)
1138           self->insert(self->begin()+index, x);
1139         else
1140           throw std::out_of_range("index");
1141       }
1142 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__InsertRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1143         if (index>=0 && index<(int)self->size()+1)
1144           self->insert(self->begin()+index, values.begin(), values.end());
1145         else
1146           throw std::out_of_range("index");
1147       }
1148 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(std::vector< unsigned int > *self,int index){
1149         if (index>=0 && index<(int)self->size())
1150           self->erase(self->begin() + index);
1151         else
1152           throw std::out_of_range("index");
1153       }
1154 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(std::vector< unsigned int > *self,int index,int count){
1155         if (index < 0)
1156           throw std::out_of_range("index");
1157         if (count < 0)
1158           throw std::out_of_range("count");
1159         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1160           throw std::invalid_argument("invalid range");
1161         self->erase(self->begin()+index, self->begin()+index+count);
1162       }
1163 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__Repeat(unsigned int const &value,int count){
1164         if (count < 0)
1165           throw std::out_of_range("count");
1166         return new std::vector< unsigned int >(count, value);
1167       }
1168 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(std::vector< unsigned int > *self){
1169         std::reverse(self->begin(), self->end());
1170       }
1171 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(std::vector< unsigned int > *self,int index,int count){
1172         if (index < 0)
1173           throw std::out_of_range("index");
1174         if (count < 0)
1175           throw std::out_of_range("count");
1176         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1177           throw std::invalid_argument("invalid range");
1178         std::reverse(self->begin()+index, self->begin()+index+count);
1179       }
1180 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__SetRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1181         if (index < 0)
1182           throw std::out_of_range("index");
1183         if (index+values.size() > self->size())
1184           throw std::out_of_range("index");
1185         std::copy(values.begin(), values.end(), self->begin()+index);
1186       }
1187 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Contains(std::vector< unsigned int > *self,unsigned int const &value){
1188         return std::find(self->begin(), self->end(), value) != self->end();
1189       }
1190 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__IndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1191         int index = -1;
1192         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1193         if (it != self->end())
1194           index = (int)(it - self->begin());
1195         return index;
1196       }
1197 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1198         int index = -1;
1199         std::vector< unsigned int >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
1200         if (rit != self->rend())
1201           index = (int)(self->rend() - 1 - rit);
1202         return index;
1203       }
1204 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Remove(std::vector< unsigned int > *self,unsigned int const &value){
1205         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1206         if (it != self->end()) {
1207           self->erase(it);
1208           return true;
1209         }
1210         return false;
1211       }
1212 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){
1213         std::vector< std::pair< unsigned int,Dali::Actor > >* pv = 0;
1214         if (capacity >= 0) {
1215           pv = new std::vector< std::pair< unsigned int,Dali::Actor > >();
1216           pv->reserve(capacity);
1217        } else {
1218           throw std::out_of_range("capacity");
1219        }
1220        return pv;
1221       }
1222 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){
1223         if (index>=0 && index<(int)self->size())
1224           return (*self)[index];
1225         else
1226           throw std::out_of_range("index");
1227       }
1228 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){
1229         if (index>=0 && index<(int)self->size())
1230           return (*self)[index];
1231         else
1232           throw std::out_of_range("index");
1233       }
1234 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){
1235         if (index>=0 && index<(int)self->size())
1236           (*self)[index] = val;
1237         else
1238           throw std::out_of_range("index");
1239       }
1240 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){
1241         self->insert(self->end(), values.begin(), values.end());
1242       }
1243 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){
1244         if (index < 0)
1245           throw std::out_of_range("index");
1246         if (count < 0)
1247           throw std::out_of_range("count");
1248         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1249           throw std::invalid_argument("invalid range");
1250         return new std::vector< std::pair< unsigned int,Dali::Actor > >(self->begin()+index, self->begin()+index+count);
1251       }
1252 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){
1253         if (index>=0 && index<(int)self->size()+1)
1254           self->insert(self->begin()+index, x);
1255         else
1256           throw std::out_of_range("index");
1257       }
1258 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){
1259         if (index>=0 && index<(int)self->size()+1)
1260           self->insert(self->begin()+index, values.begin(), values.end());
1261         else
1262           throw std::out_of_range("index");
1263       }
1264 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){
1265         if (index>=0 && index<(int)self->size())
1266           self->erase(self->begin() + index);
1267         else
1268           throw std::out_of_range("index");
1269       }
1270 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){
1271         if (index < 0)
1272           throw std::out_of_range("index");
1273         if (count < 0)
1274           throw std::out_of_range("count");
1275         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1276           throw std::invalid_argument("invalid range");
1277         self->erase(self->begin()+index, self->begin()+index+count);
1278       }
1279 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){
1280         if (count < 0)
1281           throw std::out_of_range("count");
1282         return new std::vector< std::pair< unsigned int,Dali::Actor > >(count, value);
1283       }
1284 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){
1285         std::reverse(self->begin(), self->end());
1286       }
1287 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){
1288         if (index < 0)
1289           throw std::out_of_range("index");
1290         if (count < 0)
1291           throw std::out_of_range("count");
1292         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1293           throw std::invalid_argument("invalid range");
1294         std::reverse(self->begin()+index, self->begin()+index+count);
1295       }
1296 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){
1297         if (index < 0)
1298           throw std::out_of_range("index");
1299         if (index+values.size() > self->size())
1300           throw std::out_of_range("index");
1301         std::copy(values.begin(), values.end(), self->begin()+index);
1302       }
1303 SWIGINTERN std::vector< Dali::Actor > *new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(int capacity){
1304         std::vector< Dali::Actor >* pv = 0;
1305         if (capacity >= 0) {
1306           pv = new std::vector< Dali::Actor >();
1307           pv->reserve(capacity);
1308        } else {
1309           throw std::out_of_range("capacity");
1310        }
1311        return pv;
1312       }
1313 SWIGINTERN Dali::Actor std_vector_Sl_Dali_Actor_Sg__getitemcopy(std::vector< Dali::Actor > *self,int index){
1314         if (index>=0 && index<(int)self->size())
1315           return (*self)[index];
1316         else
1317           throw std::out_of_range("index");
1318       }
1319 SWIGINTERN Dali::Actor const &std_vector_Sl_Dali_Actor_Sg__getitem(std::vector< Dali::Actor > *self,int index){
1320         if (index>=0 && index<(int)self->size())
1321           return (*self)[index];
1322         else
1323           throw std::out_of_range("index");
1324       }
1325 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__setitem(std::vector< Dali::Actor > *self,int index,Dali::Actor const &val){
1326         if (index>=0 && index<(int)self->size())
1327           (*self)[index] = val;
1328         else
1329           throw std::out_of_range("index");
1330       }
1331 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__AddRange(std::vector< Dali::Actor > *self,std::vector< Dali::Actor > const &values){
1332         self->insert(self->end(), values.begin(), values.end());
1333       }
1334 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__GetRange(std::vector< Dali::Actor > *self,int index,int count){
1335         if (index < 0)
1336           throw std::out_of_range("index");
1337         if (count < 0)
1338           throw std::out_of_range("count");
1339         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1340           throw std::invalid_argument("invalid range");
1341         return new std::vector< Dali::Actor >(self->begin()+index, self->begin()+index+count);
1342       }
1343 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Insert(std::vector< Dali::Actor > *self,int index,Dali::Actor const &x){
1344         if (index>=0 && index<(int)self->size()+1)
1345           self->insert(self->begin()+index, x);
1346         else
1347           throw std::out_of_range("index");
1348       }
1349 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__InsertRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1350         if (index>=0 && index<(int)self->size()+1)
1351           self->insert(self->begin()+index, values.begin(), values.end());
1352         else
1353           throw std::out_of_range("index");
1354       }
1355 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveAt(std::vector< Dali::Actor > *self,int index){
1356         if (index>=0 && index<(int)self->size())
1357           self->erase(self->begin() + index);
1358         else
1359           throw std::out_of_range("index");
1360       }
1361 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveRange(std::vector< Dali::Actor > *self,int index,int count){
1362         if (index < 0)
1363           throw std::out_of_range("index");
1364         if (count < 0)
1365           throw std::out_of_range("count");
1366         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1367           throw std::invalid_argument("invalid range");
1368         self->erase(self->begin()+index, self->begin()+index+count);
1369       }
1370 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__Repeat(Dali::Actor const &value,int count){
1371         if (count < 0)
1372           throw std::out_of_range("count");
1373         return new std::vector< Dali::Actor >(count, value);
1374       }
1375 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(std::vector< Dali::Actor > *self){
1376         std::reverse(self->begin(), self->end());
1377       }
1378 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(std::vector< Dali::Actor > *self,int index,int count){
1379         if (index < 0)
1380           throw std::out_of_range("index");
1381         if (count < 0)
1382           throw std::out_of_range("count");
1383         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1384           throw std::invalid_argument("invalid range");
1385         std::reverse(self->begin()+index, self->begin()+index+count);
1386       }
1387 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__SetRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1388         if (index < 0)
1389           throw std::out_of_range("index");
1390         if (index+values.size() > self->size())
1391           throw std::out_of_range("index");
1392         std::copy(values.begin(), values.end(), self->begin()+index);
1393       }
1394 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1395          return self->Empty();
1396       }
1397 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1398         return self->GetConnectionCount();
1399       }
1400 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 &)){
1401           self->Connect( func );
1402       }
1403 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 &)){
1404           self->Disconnect( func );
1405       }
1406 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){
1407           return self->Emit( arg );
1408       }
1409 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){
1410          return self->Empty();
1411       }
1412 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){
1413         return self->GetConnectionCount();
1414       }
1415 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)){
1416         self->Connect( func );
1417       }
1418 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)){
1419         self->Disconnect( func );
1420       }
1421 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){
1422         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1423 /*@SWIG@*/ self->Emit( arg1, arg2 );
1424       }
1425 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1426          return self->Empty();
1427       }
1428 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){
1429         return self->GetConnectionCount();
1430       }
1431 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)){
1432         self->Connect( func );
1433       }
1434 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)){
1435         self->Disconnect( func );
1436       }
1437 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){
1438         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1439 /*@SWIG@*/ self->Emit( arg1, arg2 );
1440       }
1441 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool) > const *self){
1442          return self->Empty();
1443       }
1444 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool) > const *self){
1445         return self->GetConnectionCount();
1446       }
1447 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)){
1448         self->Connect( func );
1449       }
1450 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)){
1451         self->Disconnect( func );
1452       }
1453 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){
1454         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1455 /*@SWIG@*/ self->Emit( arg1, arg2 );
1456       }
1457 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){
1458          return self->Empty();
1459       }
1460 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){
1461         return self->GetConnectionCount();
1462       }
1463 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)){
1464         self->Connect( func );
1465       }
1466 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)){
1467         self->Disconnect( func );
1468       }
1469 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){
1470         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1471 /*@SWIG@*/ self->Emit( arg1, arg2 );
1472       }
1473 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1474          return self->Empty();
1475       }
1476 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1477         return self->GetConnectionCount();
1478       }
1479 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)){
1480           self->Connect( func );
1481       }
1482 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)){
1483           self->Disconnect( func );
1484       }
1485 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Button) > *self,Dali::Toolkit::Button arg){
1486           return self->Emit( arg );
1487       }
1488 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1489          return self->Empty();
1490       }
1491 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1492         return self->GetConnectionCount();
1493       }
1494 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)){
1495           self->Connect( func );
1496       }
1497 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)){
1498           self->Disconnect( func );
1499       }
1500 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,Dali::Toolkit::GaussianBlurView arg){
1501           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1502 /*@SWIG@*/ self->Emit( arg );
1503       }
1504 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > const *self){
1505          return self->Empty();
1506       }
1507 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){
1508         return self->GetConnectionCount();
1509       }
1510 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)){
1511           return self->Connect( func );
1512       }
1513 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)){
1514           self->Disconnect( func );
1515       }
1516 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){
1517           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1518 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1519       }
1520 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1521          return self->Empty();
1522       }
1523 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1524         return self->GetConnectionCount();
1525       }
1526 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)){
1527           self->Connect( func );
1528       }
1529 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)){
1530           self->Disconnect( func );
1531       }
1532 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,Dali::Toolkit::PageTurnView arg){
1533           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1534 /*@SWIG@*/ self->Emit( arg );
1535       }
1536 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > const *self){
1537          return self->Empty();
1538       }
1539 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){
1540         return self->GetConnectionCount();
1541       }
1542 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)){
1543           return self->Connect( func );
1544       }
1545 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)){
1546           self->Disconnect( func );
1547       }
1548 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){
1549           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1550 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1551       }
1552 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){
1553          return self->Empty();
1554       }
1555 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){
1556         return self->GetConnectionCount();
1557       }
1558 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 &)){
1559           self->Connect( func );
1560       }
1561 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 &)){
1562           self->Disconnect( func );
1563       }
1564 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){
1565           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1566 /*@SWIG@*/ self->Emit( arg );
1567       }
1568 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1569          return self->Empty();
1570       }
1571 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){
1572         return self->GetConnectionCount();
1573       }
1574 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 &)){
1575           self->Connect( func );
1576       }
1577 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 &)){
1578           self->Disconnect( func );
1579       }
1580 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){
1581           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1582 /*@SWIG@*/ self->Emit( arg );
1583       }
1584
1585
1586 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){
1587          return self->Empty();
1588       }
1589 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){
1590         return self->GetConnectionCount();
1591       }
1592 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 &)){
1593         self->Connect( func );
1594       }
1595 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 &)){
1596         self->Disconnect( func );
1597       }
1598 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){
1599         return self->Emit( arg1, arg2 );
1600       }
1601 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1602          return self->Empty();
1603       }
1604 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1605         return self->GetConnectionCount();
1606       }
1607 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)){
1608           self->Connect( func );
1609       }
1610 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)){
1611           self->Disconnect( func );
1612       }
1613 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::Control) > *self,Dali::Toolkit::Control arg){
1614           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1615 /*@SWIG@*/ self->Emit( arg );
1616       }
1617 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1618          return self->Empty();
1619       }
1620 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1621         return self->GetConnectionCount();
1622       }
1623 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 &)){
1624           self->Connect( func );
1625       }
1626 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 &)){
1627           self->Disconnect( func );
1628       }
1629 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){
1630           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1631 /*@SWIG@*/ self->Emit( arg );
1632       }
1633 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1634          return self->Empty();
1635       }
1636 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){
1637         return self->GetConnectionCount();
1638       }
1639 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)){
1640         self->Connect( func );
1641       }
1642 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)){
1643         self->Disconnect( func );
1644       }
1645 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){
1646         return self->Emit( arg1, arg2 );
1647       }
1648 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1649          return self->Empty();
1650       }
1651 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){
1652         return self->GetConnectionCount();
1653       }
1654 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)){
1655         self->Connect( func );
1656       }
1657 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)){
1658         self->Disconnect( func );
1659       }
1660 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){
1661         return self->Emit( arg1, arg2 );
1662       }
1663
1664 /* ---------------------------------------------------
1665  * C++ director class methods
1666  * --------------------------------------------------- */
1667
1668 #include "dali_wrap.h"
1669
1670 /*
1671  *  Widget director
1672  */
1673 SwigDirector_WidgetImpl::SwigDirector_WidgetImpl() : Dali::Internal::Adaptor::Widget(), Swig::Director() {
1674   swig_init_callbacks();
1675 }
1676
1677 SwigDirector_WidgetImpl::~SwigDirector_WidgetImpl() {
1678 }
1679
1680 void SwigDirector_WidgetImpl::OnCreate(std::string const &contentInfo, Dali::Window window) {
1681   char * jcontentInfo = 0 ;
1682   void * jwindow  ;
1683
1684   if (!swig_callbackOnCreate) {
1685     Dali::Internal::Adaptor::Widget::OnCreate(contentInfo,window);
1686     return;
1687   } else {
1688     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1689     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1690     swig_callbackOnCreate(jcontentInfo, jwindow);
1691   }
1692 }
1693
1694 void SwigDirector_WidgetImpl::OnTerminate(std::string const &contentInfo, Dali::Widget::Termination type) {
1695   char * jcontentInfo = 0 ;
1696   int jtype  ;
1697
1698   if (!swig_callbackOnTerminate) {
1699     Dali::Internal::Adaptor::Widget::OnTerminate(contentInfo,type);
1700     return;
1701   } else {
1702     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1703     jtype = (int)type;
1704     swig_callbackOnTerminate(jcontentInfo, jtype);
1705   }
1706 }
1707
1708 void SwigDirector_WidgetImpl::OnPause() {
1709   if (!swig_callbackOnPause) {
1710     Dali::Internal::Adaptor::Widget::OnPause();
1711     return;
1712   } else {
1713     swig_callbackOnPause();
1714   }
1715 }
1716
1717 void SwigDirector_WidgetImpl::OnResume() {
1718   if (!swig_callbackOnResume) {
1719     Dali::Internal::Adaptor::Widget::OnResume();
1720     return;
1721   } else {
1722     swig_callbackOnResume();
1723   }
1724 }
1725
1726 void SwigDirector_WidgetImpl::OnResize(Dali::Window window) {
1727   void * jwindow  ;
1728
1729   if (!swig_callbackOnResize) {
1730     Dali::Internal::Adaptor::Widget::OnResize(window);
1731     return;
1732   } else {
1733     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1734     swig_callbackOnResize(jwindow);
1735   }
1736 }
1737
1738 void SwigDirector_WidgetImpl::OnUpdate(std::string const &contentInfo, int force) {
1739   char * jcontentInfo = 0 ;
1740   int jforce  ;
1741
1742   if (!swig_callbackOnUpdate) {
1743     Dali::Internal::Adaptor::Widget::OnUpdate(contentInfo,force);
1744     return;
1745   } else {
1746     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1747     jforce = force;
1748     swig_callbackOnUpdate(jcontentInfo, jforce);
1749   }
1750 }
1751
1752 void SwigDirector_WidgetImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1753   void * jslotObserver = 0 ;
1754   void * jcallback = 0 ;
1755
1756   if (!swig_callbackSignalConnected) {
1757     Dali::Internal::Adaptor::Widget::SignalConnected(slotObserver,callback);
1758     return;
1759   } else {
1760     jslotObserver = (void *) slotObserver;
1761     jcallback = (void *) callback;
1762     swig_callbackSignalConnected(jslotObserver, jcallback);
1763   }
1764 }
1765
1766 void SwigDirector_WidgetImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1767   void * jslotObserver = 0 ;
1768   void * jcallback = 0 ;
1769
1770   if (!swig_callbackSignalDisconnected) {
1771     Dali::Internal::Adaptor::Widget::SignalDisconnected(slotObserver,callback);
1772     return;
1773   } else {
1774     jslotObserver = (void *) slotObserver;
1775     jcallback = (void *) callback;
1776     swig_callbackSignalDisconnected(jslotObserver, jcallback);
1777   }
1778 }
1779
1780 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) {
1781
1782   swig_callbackOnCreate = callbackOnCreate;
1783   swig_callbackOnTerminate = callbackOnTerminate;
1784   swig_callbackOnPause = callbackOnPause;
1785   swig_callbackOnResume = callbackOnResume;
1786   swig_callbackOnResize = callbackOnResize;
1787   swig_callbackOnUpdate = callbackOnUpdate;
1788   swig_callbackSignalConnected = callbackSignalConnected;
1789   swig_callbackSignalDisconnected = callbackSignalDisconnected;
1790 }
1791
1792 void SwigDirector_WidgetImpl::swig_init_callbacks() {
1793   swig_callbackOnCreate = 0;
1794   swig_callbackOnTerminate = 0;
1795   swig_callbackOnPause = 0;
1796   swig_callbackOnResume = 0;
1797   swig_callbackOnResize = 0;
1798   swig_callbackOnUpdate = 0;
1799   swig_callbackSignalConnected = 0;
1800   swig_callbackSignalDisconnected = 0;
1801 }
1802
1803
1804 SwigDirector_ViewImpl::SwigDirector_ViewImpl(Dali::Toolkit::Internal::Control::ControlBehaviour behaviourFlags) : Dali::Toolkit::Internal::Control(behaviourFlags), Swig::Director() {
1805   swig_init_callbacks();
1806 }
1807
1808 SwigDirector_ViewImpl::~SwigDirector_ViewImpl() {
1809
1810 }
1811
1812
1813 void SwigDirector_ViewImpl::OnSceneConnection(int depth) {
1814   int jdepth  ;
1815
1816   if (!swig_callbackOnSceneConnection) {
1817     Dali::Toolkit::Internal::Control::OnSceneConnection(depth);
1818     return;
1819   } else {
1820     jdepth = depth;
1821     swig_callbackOnSceneConnection(jdepth);
1822   }
1823 }
1824
1825 void SwigDirector_ViewImpl::OnSceneDisconnection() {
1826   if (!swig_callbackOnSceneDisconnection) {
1827     Dali::Toolkit::Internal::Control::OnSceneDisconnection();
1828     return;
1829   } else {
1830     swig_callbackOnSceneDisconnection();
1831   }
1832 }
1833
1834 void SwigDirector_ViewImpl::OnChildAdd(Dali::Actor &child) {
1835   void * jchild = 0 ;
1836
1837   if (!swig_callbackOnChildAdd) {
1838     Dali::Toolkit::Internal::Control::OnChildAdd(child);
1839     return;
1840   } else {
1841     jchild = (Dali::Actor *) &child;
1842     swig_callbackOnChildAdd(jchild);
1843   }
1844 }
1845
1846 void SwigDirector_ViewImpl::OnChildRemove(Dali::Actor &child) {
1847   void * jchild = 0 ;
1848
1849   if (!swig_callbackOnChildRemove) {
1850     Dali::Toolkit::Internal::Control::OnChildRemove(child);
1851     return;
1852   } else {
1853     jchild = (Dali::Actor *) &child;
1854     swig_callbackOnChildRemove(jchild);
1855   }
1856 }
1857
1858 void SwigDirector_ViewImpl::OnPropertySet(Dali::Property::Index index, Dali::Property::Value propertyValue) {
1859   int jindex  ;
1860   void * jpropertyValue  ;
1861
1862   if (!swig_callbackOnPropertySet) {
1863     Dali::Toolkit::Internal::Control::OnPropertySet(index,propertyValue);
1864     return;
1865   } else {
1866     jindex = index;
1867     jpropertyValue = (void *)new Dali::Property::Value((const Dali::Property::Value &)propertyValue);
1868     swig_callbackOnPropertySet(jindex, jpropertyValue);
1869   }
1870 }
1871
1872 void SwigDirector_ViewImpl::OnSizeSet(Dali::Vector3 const &targetSize) {
1873   void * jtargetSize = 0 ;
1874
1875   if (!swig_callbackOnSizeSet) {
1876     Dali::Toolkit::Internal::Control::OnSizeSet(targetSize);
1877     return;
1878   } else {
1879     jtargetSize = (Dali::Vector3 *) &targetSize;
1880     swig_callbackOnSizeSet(jtargetSize);
1881   }
1882 }
1883
1884 void SwigDirector_ViewImpl::OnSizeAnimation(Dali::Animation &animation, Dali::Vector3 const &targetSize) {
1885   void * janimation = 0 ;
1886   void * jtargetSize = 0 ;
1887
1888   if (!swig_callbackOnSizeAnimation) {
1889     Dali::Toolkit::Internal::Control::OnSizeAnimation(animation,targetSize);
1890     return;
1891   } else {
1892     janimation = (Dali::Animation *) &animation;
1893     jtargetSize = (Dali::Vector3 *) &targetSize;
1894     swig_callbackOnSizeAnimation(janimation, jtargetSize);
1895   }
1896 }
1897
1898 bool SwigDirector_ViewImpl::OnHoverEvent(Dali::HoverEvent const &event) {
1899   bool c_result = SwigValueInit< bool >() ;
1900   unsigned int jresult = 0 ;
1901   void * jarg0 = 0 ;
1902
1903   if (!swig_callbackOnHoverEvent) {
1904     return Dali::Toolkit::Internal::Control::OnHoverEvent(event);
1905   } else {
1906     jarg0 = (Dali::HoverEvent *) &event;
1907     jresult = (unsigned int) swig_callbackOnHoverEvent(jarg0);
1908     c_result = jresult ? true : false;
1909   }
1910   return c_result;
1911 }
1912
1913 bool SwigDirector_ViewImpl::OnKeyEvent(Dali::KeyEvent const &event) {
1914   bool c_result = SwigValueInit< bool >() ;
1915   unsigned int jresult = 0 ;
1916   void * jarg0 = 0 ;
1917
1918   if (!swig_callbackOnKeyEvent) {
1919     return Dali::Toolkit::Internal::Control::OnKeyEvent(event);
1920   } else {
1921     jarg0 = (Dali::KeyEvent *) &event;
1922     jresult = (unsigned int) swig_callbackOnKeyEvent(jarg0);
1923     c_result = jresult ? true : false;
1924   }
1925   return c_result;
1926 }
1927
1928 bool SwigDirector_ViewImpl::OnWheelEvent(Dali::WheelEvent const &event) {
1929   bool c_result = SwigValueInit< bool >() ;
1930   unsigned int jresult = 0 ;
1931   void * jarg0 = 0 ;
1932
1933   if (!swig_callbackOnWheelEvent) {
1934     return Dali::Toolkit::Internal::Control::OnWheelEvent(event);
1935   } else {
1936     jarg0 = (Dali::WheelEvent *) &event;
1937     jresult = (unsigned int) swig_callbackOnWheelEvent(jarg0);
1938     c_result = jresult ? true : false;
1939   }
1940   return c_result;
1941 }
1942
1943 void SwigDirector_ViewImpl::OnRelayout(Dali::Vector2 const &size, Dali::RelayoutContainer &container) {
1944   void * jsize = 0 ;
1945   void * jcontainer = 0 ;
1946
1947   if (!swig_callbackOnRelayout) {
1948     Dali::Toolkit::Internal::Control::OnRelayout(size,container);
1949     return;
1950   } else {
1951     jsize = (Dali::Vector2 *) &size;
1952     jcontainer = (Dali::RelayoutContainer *) &container;
1953     swig_callbackOnRelayout(jsize, jcontainer);
1954   }
1955 }
1956
1957 void SwigDirector_ViewImpl::OnSetResizePolicy(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension) {
1958   int jpolicy  ;
1959   int jdimension  ;
1960
1961   if (!swig_callbackOnSetResizePolicy) {
1962     Dali::Toolkit::Internal::Control::OnSetResizePolicy(policy,dimension);
1963     return;
1964   } else {
1965     jpolicy = (int)policy;
1966     jdimension = (int)dimension;
1967     swig_callbackOnSetResizePolicy(jpolicy, jdimension);
1968   }
1969 }
1970
1971 Dali::Vector3 SwigDirector_ViewImpl::GetNaturalSize() {
1972   Dali::Vector3 c_result ;
1973   void * jresult = 0 ;
1974
1975   if (!swig_callbackGetNaturalSize) {
1976     return Dali::Toolkit::Internal::Control::GetNaturalSize();
1977   } else {
1978     jresult = (void *) swig_callbackGetNaturalSize();
1979     if (!jresult) {
1980       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Vector3", 0);
1981       return c_result;
1982     }
1983     c_result = *(Dali::Vector3 *)jresult;
1984   }
1985   return c_result;
1986 }
1987
1988 float SwigDirector_ViewImpl::CalculateChildSize(Dali::Actor const &child, Dali::Dimension::Type dimension) {
1989   float c_result = SwigValueInit< float >() ;
1990   float jresult = 0 ;
1991   void * jchild = 0 ;
1992   int jdimension  ;
1993
1994   if (!swig_callbackCalculateChildSize) {
1995     return Dali::Toolkit::Internal::Control::CalculateChildSize(child,dimension);
1996   } else {
1997     jchild = (Dali::Actor *) &child;
1998     jdimension = (int)dimension;
1999     jresult = (float) swig_callbackCalculateChildSize(jchild, jdimension);
2000     c_result = (float)jresult;
2001   }
2002   return c_result;
2003 }
2004
2005 float SwigDirector_ViewImpl::GetHeightForWidth(float width) {
2006   float c_result = SwigValueInit< float >() ;
2007   float jresult = 0 ;
2008   float jwidth  ;
2009
2010   if (!swig_callbackGetHeightForWidth) {
2011     return Dali::Toolkit::Internal::Control::GetHeightForWidth(width);
2012   } else {
2013     jwidth = width;
2014     jresult = (float) swig_callbackGetHeightForWidth(jwidth);
2015     c_result = (float)jresult;
2016   }
2017   return c_result;
2018 }
2019
2020 float SwigDirector_ViewImpl::GetWidthForHeight(float height) {
2021   float c_result = SwigValueInit< float >() ;
2022   float jresult = 0 ;
2023   float jheight  ;
2024
2025   if (!swig_callbackGetWidthForHeight) {
2026     return Dali::Toolkit::Internal::Control::GetWidthForHeight(height);
2027   } else {
2028     jheight = height;
2029     jresult = (float) swig_callbackGetWidthForHeight(jheight);
2030     c_result = (float)jresult;
2031   }
2032   return c_result;
2033 }
2034
2035 bool SwigDirector_ViewImpl::RelayoutDependentOnChildren(Dali::Dimension::Type dimension) {
2036   bool c_result = SwigValueInit< bool >() ;
2037   unsigned int jresult = 0 ;
2038   int jdimension  ;
2039
2040   if (!swig_callbackRelayoutDependentOnChildren__SWIG_0) {
2041     return Dali::Toolkit::Internal::Control::RelayoutDependentOnChildren(dimension);
2042   } else {
2043     jdimension = (int)dimension;
2044     jresult = (unsigned int) swig_callbackRelayoutDependentOnChildren__SWIG_0(jdimension);
2045     c_result = jresult ? true : false;
2046   }
2047   return c_result;
2048 }
2049
2050 void SwigDirector_ViewImpl::OnCalculateRelayoutSize(Dali::Dimension::Type dimension) {
2051   int jdimension  ;
2052
2053   if (!swig_callbackOnCalculateRelayoutSize) {
2054     Dali::Toolkit::Internal::Control::OnCalculateRelayoutSize(dimension);
2055     return;
2056   } else {
2057     jdimension = (int)dimension;
2058     swig_callbackOnCalculateRelayoutSize(jdimension);
2059   }
2060 }
2061
2062 void SwigDirector_ViewImpl::OnLayoutNegotiated(float size, Dali::Dimension::Type dimension) {
2063   float jsize  ;
2064   int jdimension  ;
2065
2066   if (!swig_callbackOnLayoutNegotiated) {
2067     Dali::Toolkit::Internal::Control::OnLayoutNegotiated(size,dimension);
2068     return;
2069   } else {
2070     jsize = size;
2071     jdimension = (int)dimension;
2072     swig_callbackOnLayoutNegotiated(jsize, jdimension);
2073   }
2074 }
2075
2076 Dali::CustomActorImpl::Extension *SwigDirector_ViewImpl::GetExtension() {
2077   return Dali::CustomActorImpl::GetExtension();
2078 }
2079
2080 void SwigDirector_ViewImpl::OnInitialize() {
2081   if (!swig_callbackOnInitialize) {
2082     Dali::Toolkit::Internal::Control::OnInitialize();
2083     return;
2084   } else {
2085     swig_callbackOnInitialize();
2086   }
2087 }
2088
2089 void SwigDirector_ViewImpl::OnStyleChange(Dali::Toolkit::StyleManager styleManager, Dali::StyleChange::Type change) {
2090   void * jstyleManager  ;
2091   int jchange  ;
2092
2093   if (!swig_callbackOnStyleChange) {
2094     Dali::Toolkit::Internal::Control::OnStyleChange(styleManager,change);
2095     return;
2096   } else {
2097     jstyleManager = (void *)new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)styleManager);
2098     jchange = (int)change;
2099     swig_callbackOnStyleChange(jstyleManager, jchange);
2100   }
2101 }
2102
2103 bool SwigDirector_ViewImpl::OnAccessibilityActivated() {
2104   bool c_result = SwigValueInit< bool >() ;
2105   unsigned int jresult = 0 ;
2106
2107   if (!swig_callbackOnAccessibilityActivated) {
2108     return Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
2109   } else {
2110     jresult = (unsigned int) swig_callbackOnAccessibilityActivated();
2111     c_result = jresult ? true : false;
2112   }
2113   return c_result;
2114 }
2115
2116 bool SwigDirector_ViewImpl::OnAccessibilityPan(Dali::PanGesture gesture) {
2117   bool c_result = SwigValueInit< bool >() ;
2118   unsigned int jresult = 0 ;
2119   void * jgesture  ;
2120
2121   if (!swig_callbackOnAccessibilityPan) {
2122     return Dali::Toolkit::Internal::Control::OnAccessibilityPan(gesture);
2123   } else {
2124     jgesture = (void *)new Dali::PanGesture((const Dali::PanGesture &)gesture);
2125     jresult = (unsigned int) swig_callbackOnAccessibilityPan(jgesture);
2126     c_result = jresult ? true : false;
2127   }
2128   return c_result;
2129 }
2130
2131 bool SwigDirector_ViewImpl::OnAccessibilityValueChange(bool isIncrease) {
2132   bool c_result = SwigValueInit< bool >() ;
2133   unsigned int jresult = 0 ;
2134   unsigned int jisIncrease  ;
2135
2136   if (!swig_callbackOnAccessibilityValueChange) {
2137     return Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(isIncrease);
2138   } else {
2139     jisIncrease = isIncrease;
2140     jresult = (unsigned int) swig_callbackOnAccessibilityValueChange(jisIncrease);
2141     c_result = jresult ? true : false;
2142   }
2143   return c_result;
2144 }
2145
2146 bool SwigDirector_ViewImpl::OnAccessibilityZoom() {
2147   bool c_result = SwigValueInit< bool >() ;
2148   unsigned int jresult = 0 ;
2149
2150   if (!swig_callbackOnAccessibilityZoom) {
2151     return Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
2152   } else {
2153     jresult = (unsigned int) swig_callbackOnAccessibilityZoom();
2154     c_result = jresult ? true : false;
2155   }
2156   return c_result;
2157 }
2158
2159 void SwigDirector_ViewImpl::OnKeyInputFocusGained() {
2160   if (!swig_callbackOnKeyInputFocusGained) {
2161     Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
2162     return;
2163   } else {
2164     swig_callbackOnKeyInputFocusGained();
2165   }
2166 }
2167
2168 void SwigDirector_ViewImpl::OnKeyInputFocusLost() {
2169   if (!swig_callbackOnKeyInputFocusLost) {
2170     Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
2171     return;
2172   } else {
2173     swig_callbackOnKeyInputFocusLost();
2174   }
2175 }
2176
2177 Dali::Actor SwigDirector_ViewImpl::GetNextKeyboardFocusableActor(Dali::Actor currentFocusedActor, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled) {
2178   Dali::Actor c_result ;
2179   void * jresult = 0 ;
2180   void * jcurrentFocusedActor  ;
2181   int jdirection  ;
2182   unsigned int jloopEnabled  ;
2183
2184   if (!swig_callbackGetNextKeyboardFocusableActor) {
2185     return Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(currentFocusedActor,direction,loopEnabled);
2186   } else {
2187     jcurrentFocusedActor = (void *)new Dali::Actor((const Dali::Actor &)currentFocusedActor);
2188     jdirection = (int)direction;
2189     jloopEnabled = loopEnabled;
2190     jresult = (void *) swig_callbackGetNextKeyboardFocusableActor(jcurrentFocusedActor, jdirection, jloopEnabled);
2191     if (!jresult) {
2192       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2193       return c_result;
2194     }
2195     c_result = *(Dali::Actor *)jresult;
2196   }
2197   return c_result;
2198 }
2199
2200 void SwigDirector_ViewImpl::OnKeyboardFocusChangeCommitted(Dali::Actor commitedFocusableActor) {
2201   void * jcommitedFocusableActor  ;
2202
2203   if (!swig_callbackOnKeyboardFocusChangeCommitted) {
2204     Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(commitedFocusableActor);
2205     return;
2206   } else {
2207     jcommitedFocusableActor = (void *)new Dali::Actor((const Dali::Actor &)commitedFocusableActor);
2208     swig_callbackOnKeyboardFocusChangeCommitted(jcommitedFocusableActor);
2209   }
2210 }
2211
2212 bool SwigDirector_ViewImpl::OnKeyboardEnter() {
2213   bool c_result = SwigValueInit< bool >() ;
2214   unsigned int jresult = 0 ;
2215
2216   if (!swig_callbackOnKeyboardEnter) {
2217     return Dali::Toolkit::Internal::Control::OnKeyboardEnter();
2218   } else {
2219     jresult = (unsigned int) swig_callbackOnKeyboardEnter();
2220     c_result = jresult ? true : false;
2221   }
2222   return c_result;
2223 }
2224
2225 void SwigDirector_ViewImpl::OnPinch(Dali::PinchGesture const &pinch) {
2226   void * jpinch = 0 ;
2227
2228   if (!swig_callbackOnPinch) {
2229     Dali::Toolkit::Internal::Control::OnPinch(pinch);
2230     return;
2231   } else {
2232     jpinch = (Dali::PinchGesture *) &pinch;
2233     swig_callbackOnPinch(jpinch);
2234   }
2235 }
2236
2237 void SwigDirector_ViewImpl::OnPan(Dali::PanGesture const &pan) {
2238   void * jpan = 0 ;
2239
2240   if (!swig_callbackOnPan) {
2241     Dali::Toolkit::Internal::Control::OnPan(pan);
2242     return;
2243   } else {
2244     jpan = (Dali::PanGesture *) &pan;
2245     swig_callbackOnPan(jpan);
2246   }
2247 }
2248
2249 void SwigDirector_ViewImpl::OnTap(Dali::TapGesture const &tap) {
2250   void * jtap = 0 ;
2251
2252   if (!swig_callbackOnTap) {
2253     Dali::Toolkit::Internal::Control::OnTap(tap);
2254     return;
2255   } else {
2256     jtap = (Dali::TapGesture *) &tap;
2257     swig_callbackOnTap(jtap);
2258   }
2259 }
2260
2261 void SwigDirector_ViewImpl::OnLongPress(Dali::LongPressGesture const &longPress) {
2262   void * jlongPress = 0 ;
2263
2264   if (!swig_callbackOnLongPress) {
2265     Dali::Toolkit::Internal::Control::OnLongPress(longPress);
2266     return;
2267   } else {
2268     jlongPress = (Dali::LongPressGesture *) &longPress;
2269     swig_callbackOnLongPress(jlongPress);
2270   }
2271 }
2272
2273 void SwigDirector_ViewImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2274   void * jslotObserver = 0 ;
2275   void * jcallback = 0 ;
2276
2277   if (!swig_callbackSignalConnected) {
2278     Dali::Toolkit::Internal::Control::SignalConnected(slotObserver,callback);
2279     return;
2280   } else {
2281     jslotObserver = (void *) slotObserver;
2282     jcallback = (void *) callback;
2283     swig_callbackSignalConnected(jslotObserver, jcallback);
2284   }
2285 }
2286
2287 void SwigDirector_ViewImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2288   void * jslotObserver = 0 ;
2289   void * jcallback = 0 ;
2290
2291   if (!swig_callbackSignalDisconnected) {
2292     Dali::Toolkit::Internal::Control::SignalDisconnected(slotObserver,callback);
2293     return;
2294   } else {
2295     jslotObserver = (void *) slotObserver;
2296     jcallback = (void *) callback;
2297     swig_callbackSignalDisconnected(jslotObserver, jcallback);
2298   }
2299 }
2300
2301 Dali::Toolkit::Internal::Control::Extension *SwigDirector_ViewImpl::GetControlExtension() {
2302   return Dali::Toolkit::Internal::Control::GetControlExtension();
2303 }
2304
2305 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) {
2306   swig_callbackOnSceneConnection = callbackOnSceneConnection;
2307   swig_callbackOnSceneDisconnection = callbackOnSceneDisconnection;
2308   swig_callbackOnChildAdd = callbackOnChildAdd;
2309   swig_callbackOnChildRemove = callbackOnChildRemove;
2310   swig_callbackOnPropertySet = callbackOnPropertySet;
2311   swig_callbackOnSizeSet = callbackOnSizeSet;
2312   swig_callbackOnSizeAnimation = callbackOnSizeAnimation;
2313   swig_callbackOnHoverEvent = callbackOnHoverEvent;
2314   swig_callbackOnKeyEvent = callbackOnKeyEvent;
2315   swig_callbackOnWheelEvent = callbackOnWheelEvent;
2316   swig_callbackOnRelayout = callbackOnRelayout;
2317   swig_callbackOnSetResizePolicy = callbackOnSetResizePolicy;
2318   swig_callbackGetNaturalSize = callbackGetNaturalSize;
2319   swig_callbackCalculateChildSize = callbackCalculateChildSize;
2320   swig_callbackGetHeightForWidth = callbackGetHeightForWidth;
2321   swig_callbackGetWidthForHeight = callbackGetWidthForHeight;
2322   swig_callbackRelayoutDependentOnChildren__SWIG_0 = callbackRelayoutDependentOnChildren__SWIG_0;
2323   swig_callbackRelayoutDependentOnChildren__SWIG_1 = callbackRelayoutDependentOnChildren__SWIG_1;
2324   swig_callbackOnCalculateRelayoutSize = callbackOnCalculateRelayoutSize;
2325   swig_callbackOnLayoutNegotiated = callbackOnLayoutNegotiated;
2326   swig_callbackOnInitialize = callbackOnInitialize;
2327   swig_callbackOnStyleChange = callbackOnStyleChange;
2328   swig_callbackOnAccessibilityActivated = callbackOnAccessibilityActivated;
2329   swig_callbackOnAccessibilityPan = callbackOnAccessibilityPan;
2330   swig_callbackOnAccessibilityValueChange = callbackOnAccessibilityValueChange;
2331   swig_callbackOnAccessibilityZoom = callbackOnAccessibilityZoom;
2332   swig_callbackOnKeyInputFocusGained = callbackOnKeyInputFocusGained;
2333   swig_callbackOnKeyInputFocusLost = callbackOnKeyInputFocusLost;
2334   swig_callbackGetNextKeyboardFocusableActor = callbackGetNextKeyboardFocusableActor;
2335   swig_callbackOnKeyboardFocusChangeCommitted = callbackOnKeyboardFocusChangeCommitted;
2336   swig_callbackOnKeyboardEnter = callbackOnKeyboardEnter;
2337   swig_callbackOnPinch = callbackOnPinch;
2338   swig_callbackOnPan = callbackOnPan;
2339   swig_callbackOnTap = callbackOnTap;
2340   swig_callbackOnLongPress = callbackOnLongPress;
2341   swig_callbackSignalConnected = callbackSignalConnected;
2342   swig_callbackSignalDisconnected = callbackSignalDisconnected;
2343 }
2344
2345 void SwigDirector_ViewImpl::swig_init_callbacks() {
2346   swig_callbackOnSceneConnection = 0;
2347   swig_callbackOnSceneDisconnection = 0;
2348   swig_callbackOnChildAdd = 0;
2349   swig_callbackOnChildRemove = 0;
2350   swig_callbackOnPropertySet = 0;
2351   swig_callbackOnSizeSet = 0;
2352   swig_callbackOnSizeAnimation = 0;
2353   swig_callbackOnHoverEvent = 0;
2354   swig_callbackOnKeyEvent = 0;
2355   swig_callbackOnWheelEvent = 0;
2356   swig_callbackOnRelayout = 0;
2357   swig_callbackOnSetResizePolicy = 0;
2358   swig_callbackGetNaturalSize = 0;
2359   swig_callbackCalculateChildSize = 0;
2360   swig_callbackGetHeightForWidth = 0;
2361   swig_callbackGetWidthForHeight = 0;
2362   swig_callbackRelayoutDependentOnChildren__SWIG_0 = 0;
2363   swig_callbackRelayoutDependentOnChildren__SWIG_1 = 0;
2364   swig_callbackOnCalculateRelayoutSize = 0;
2365   swig_callbackOnLayoutNegotiated = 0;
2366   swig_callbackOnInitialize = 0;
2367   swig_callbackOnStyleChange = 0;
2368   swig_callbackOnAccessibilityActivated = 0;
2369   swig_callbackOnAccessibilityPan = 0;
2370   swig_callbackOnAccessibilityValueChange = 0;
2371   swig_callbackOnAccessibilityZoom = 0;
2372   swig_callbackOnKeyInputFocusGained = 0;
2373   swig_callbackOnKeyInputFocusLost = 0;
2374   swig_callbackGetNextKeyboardFocusableActor = 0;
2375   swig_callbackOnKeyboardFocusChangeCommitted = 0;
2376   swig_callbackOnKeyboardEnter = 0;
2377   swig_callbackOnPinch = 0;
2378   swig_callbackOnPan = 0;
2379   swig_callbackOnTap = 0;
2380   swig_callbackOnLongPress = 0;
2381   swig_callbackSignalConnected = 0;
2382   swig_callbackSignalDisconnected = 0;
2383 }
2384
2385 SwigDirector_ItemFactory::SwigDirector_ItemFactory() : Dali::Toolkit::ItemFactory(), Swig::Director() {
2386   swig_init_callbacks();
2387 }
2388
2389 SwigDirector_ItemFactory::~SwigDirector_ItemFactory() {
2390
2391 }
2392
2393
2394 unsigned int SwigDirector_ItemFactory::GetNumberOfItems() {
2395   unsigned int c_result = SwigValueInit< unsigned int >() ;
2396   unsigned int jresult = 0 ;
2397
2398   if (!swig_callbackGetNumberOfItems) {
2399     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::GetNumberOfItems");
2400   } else {
2401     jresult = (unsigned int) swig_callbackGetNumberOfItems();
2402     c_result = (unsigned int)jresult;
2403   }
2404   return c_result;
2405 }
2406
2407 Dali::Actor SwigDirector_ItemFactory::NewItem(unsigned int itemId) {
2408   Dali::Actor c_result ;
2409   void * jresult = 0 ;
2410   unsigned int jitemId  ;
2411
2412   if (!swig_callbackNewItem) {
2413     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::NewItem");
2414   } else {
2415     jitemId = itemId;
2416     jresult = (void *) swig_callbackNewItem(jitemId);
2417     if (!jresult) {
2418       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2419       return c_result;
2420     }
2421     c_result = *(Dali::Actor *)jresult;
2422   }
2423   return c_result;
2424 }
2425
2426 void SwigDirector_ItemFactory::ItemReleased(unsigned int itemId, Dali::Actor actor) {
2427   unsigned int jitemId  ;
2428   void * jactor  ;
2429
2430   if (!swig_callbackItemReleased) {
2431     Dali::Toolkit::ItemFactory::ItemReleased(itemId,actor);
2432     return;
2433   } else {
2434     jitemId = itemId;
2435     jactor = (void *)new Dali::Actor((const Dali::Actor &)actor);
2436     swig_callbackItemReleased(jitemId, jactor);
2437   }
2438 }
2439
2440 Dali::Toolkit::ItemFactory::Extension *SwigDirector_ItemFactory::GetExtension() {
2441   return Dali::Toolkit::ItemFactory::GetExtension();
2442 }
2443
2444 void SwigDirector_ItemFactory::swig_connect_director(SWIG_Callback0_t callbackGetNumberOfItems, SWIG_Callback1_t callbackNewItem, SWIG_Callback2_t callbackItemReleased) {
2445   swig_callbackGetNumberOfItems = callbackGetNumberOfItems;
2446   swig_callbackNewItem = callbackNewItem;
2447   swig_callbackItemReleased = callbackItemReleased;
2448 }
2449
2450 void SwigDirector_ItemFactory::swig_init_callbacks() {
2451   swig_callbackGetNumberOfItems = 0;
2452   swig_callbackNewItem = 0;
2453   swig_callbackItemReleased = 0;
2454 }
2455
2456 SwigDirector_CustomAlgorithmInterface::SwigDirector_CustomAlgorithmInterface() : Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface(), Swig::Director() {
2457   swig_init_callbacks();
2458 }
2459
2460 SwigDirector_CustomAlgorithmInterface::~SwigDirector_CustomAlgorithmInterface() {
2461
2462 }
2463
2464
2465 Dali::Actor SwigDirector_CustomAlgorithmInterface::GetNextFocusableActor(Dali::Actor current, Dali::Actor proposed, Dali::Toolkit::Control::KeyboardFocus::Direction direction) {
2466   Dali::Actor c_result ;
2467   void * jresult = 0 ;
2468   void * jcurrent  ;
2469   void * jproposed  ;
2470   int jdirection  ;
2471
2472   if (!swig_callbackGetNextFocusableActor) {
2473     throw Swig::DirectorPureVirtualException("Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface::GetNextFocusableActor");
2474   } else {
2475     jcurrent = (void *)new Dali::Actor((const Dali::Actor &)current);
2476     jproposed = (void *)new Dali::Actor((const Dali::Actor &)proposed);
2477     jdirection = (int)direction;
2478     jresult = (void *) swig_callbackGetNextFocusableActor(jcurrent, jproposed, jdirection);
2479     if (!jresult) {
2480       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__);
2481       return c_result;
2482     }
2483     c_result = *(Dali::Actor *)jresult;
2484   }
2485   return c_result;
2486 }
2487
2488 void SwigDirector_CustomAlgorithmInterface::swig_connect_director(SWIG_Callback0_t callbackGetNextFocusableActor) {
2489   swig_callbackGetNextFocusableActor = callbackGetNextFocusableActor;
2490 }
2491
2492 void SwigDirector_CustomAlgorithmInterface::swig_init_callbacks() {
2493   swig_callbackGetNextFocusableActor = 0;
2494 }
2495
2496 SwigDirector_FrameCallbackInterface::SwigDirector_FrameCallbackInterface() : Dali::FrameCallbackInterface(), Swig::Director() {
2497   swig_callbackOnUpdate = 0;
2498 }
2499
2500 SwigDirector_FrameCallbackInterface::~SwigDirector_FrameCallbackInterface() {
2501
2502 }
2503
2504 void SwigDirector_FrameCallbackInterface::swig_connect_director(SWIG_Callback0_t callbackUpdate) {
2505   swig_callbackOnUpdate = callbackUpdate;
2506 }
2507
2508
2509 void SwigDirector_FrameCallbackInterface::Update(Dali::UpdateProxy& updateProxy, float elapsedSeconds) {
2510   void * jcurrent  ;
2511
2512   if (!swig_callbackOnUpdate) {
2513     throw Swig::DirectorPureVirtualException("Dali::FrameCallbackInterface::Update");
2514   } else {
2515     Dali::UpdateProxy* proxy = &updateProxy;
2516     jcurrent = (void *)proxy;
2517     swig_callbackOnUpdate(jcurrent, elapsedSeconds);
2518     if (!jcurrent) {
2519       DALI_LOG_ERROR("[ERROR][%s line:%d] Unexpected null return for type Dali::UpdateProxy! ", __FILE__, __LINE__);
2520       return;
2521     }
2522   }
2523   return;
2524 }
2525
2526
2527 #ifdef __cplusplus
2528 extern "C" {
2529 #endif
2530
2531 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_floatp() {
2532   void * jresult ;
2533   floatp *result = 0 ;
2534
2535   {
2536     try {
2537       result = (floatp *)new_floatp();
2538     } CALL_CATCH_EXCEPTION(0);
2539   }
2540   jresult = (void *)result;
2541   return jresult;
2542 }
2543
2544
2545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_floatp(void * jarg1) {
2546   floatp *arg1 = (floatp *) 0 ;
2547
2548   arg1 = (floatp *)jarg1;
2549   {
2550     try {
2551       delete_floatp(arg1);
2552     } CALL_CATCH_EXCEPTION();
2553   }
2554
2555 }
2556
2557
2558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_floatp_assign(void * jarg1, float jarg2) {
2559   floatp *arg1 = (floatp *) 0 ;
2560   float arg2 ;
2561
2562   arg1 = (floatp *)jarg1;
2563   arg2 = (float)jarg2;
2564   {
2565     try {
2566       floatp_assign(arg1,arg2);
2567     } CALL_CATCH_EXCEPTION();
2568   }
2569
2570 }
2571
2572
2573 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_floatp_value(void * jarg1) {
2574   float jresult ;
2575   floatp *arg1 = (floatp *) 0 ;
2576   float result;
2577
2578   arg1 = (floatp *)jarg1;
2579   {
2580     try {
2581       result = (float)floatp_value(arg1);
2582     } CALL_CATCH_EXCEPTION(0);
2583   }
2584   jresult = result;
2585   return jresult;
2586 }
2587
2588
2589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_cast(void * jarg1) {
2590   void * jresult ;
2591   floatp *arg1 = (floatp *) 0 ;
2592   float *result = 0 ;
2593
2594   arg1 = (floatp *)jarg1;
2595   {
2596     try {
2597       result = (float *)floatp_cast(arg1);
2598     } CALL_CATCH_EXCEPTION(0);
2599   }
2600
2601   jresult = (void *)result;
2602   return jresult;
2603 }
2604
2605
2606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_frompointer(void * jarg1) {
2607   void * jresult ;
2608   float *arg1 = (float *) 0 ;
2609   floatp *result = 0 ;
2610
2611   arg1 = (float *)jarg1;
2612   {
2613     try {
2614       result = (floatp *)floatp_frompointer(arg1);
2615     } CALL_CATCH_EXCEPTION(0);
2616   }
2617
2618   jresult = (void *)result;
2619   return jresult;
2620 }
2621
2622
2623 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_intp() {
2624   void * jresult ;
2625   intp *result = 0 ;
2626
2627   {
2628     try {
2629       result = (intp *)new_intp();
2630     } CALL_CATCH_EXCEPTION(0);
2631   }
2632
2633   jresult = (void *)result;
2634   return jresult;
2635 }
2636
2637
2638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_intp(void * jarg1) {
2639   intp *arg1 = (intp *) 0 ;
2640
2641   arg1 = (intp *)jarg1;
2642   {
2643     try {
2644       delete_intp(arg1);
2645     } CALL_CATCH_EXCEPTION();
2646   }
2647
2648 }
2649
2650
2651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_intp_assign(void * jarg1, int jarg2) {
2652   intp *arg1 = (intp *) 0 ;
2653   int arg2 ;
2654
2655   arg1 = (intp *)jarg1;
2656   arg2 = (int)jarg2;
2657   {
2658     try {
2659       intp_assign(arg1,arg2);
2660     } CALL_CATCH_EXCEPTION();
2661   }
2662
2663 }
2664
2665
2666 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_intp_value(void * jarg1) {
2667   int jresult ;
2668   intp *arg1 = (intp *) 0 ;
2669   int result;
2670
2671   arg1 = (intp *)jarg1;
2672   {
2673     try {
2674       result = (int)intp_value(arg1);
2675     } CALL_CATCH_EXCEPTION(0);
2676   }
2677
2678   jresult = result;
2679   return jresult;
2680 }
2681
2682
2683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_cast(void * jarg1) {
2684   void * jresult ;
2685   intp *arg1 = (intp *) 0 ;
2686   int *result = 0 ;
2687
2688   arg1 = (intp *)jarg1;
2689   {
2690     try {
2691       result = (int *)intp_cast(arg1);
2692     } CALL_CATCH_EXCEPTION(0);
2693   }
2694
2695   jresult = (void *)result;
2696   return jresult;
2697 }
2698
2699
2700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_frompointer(void * jarg1) {
2701   void * jresult ;
2702   int *arg1 = (int *) 0 ;
2703   intp *result = 0 ;
2704
2705   arg1 = (int *)jarg1;
2706   {
2707     try {
2708       result = (intp *)intp_frompointer(arg1);
2709     } CALL_CATCH_EXCEPTION(0);
2710   }
2711
2712   jresult = (void *)result;
2713   return jresult;
2714 }
2715
2716
2717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_doublep() {
2718   void * jresult ;
2719   doublep *result = 0 ;
2720
2721   {
2722     try {
2723       result = (doublep *)new_doublep();
2724     } CALL_CATCH_EXCEPTION(0);
2725   }
2726
2727   jresult = (void *)result;
2728   return jresult;
2729 }
2730
2731
2732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_doublep(void * jarg1) {
2733   doublep *arg1 = (doublep *) 0 ;
2734
2735   arg1 = (doublep *)jarg1;
2736   {
2737     try {
2738       delete_doublep(arg1);
2739     } CALL_CATCH_EXCEPTION();
2740   }
2741
2742 }
2743
2744
2745 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_doublep_assign(void * jarg1, double jarg2) {
2746   doublep *arg1 = (doublep *) 0 ;
2747   double arg2 ;
2748
2749   arg1 = (doublep *)jarg1;
2750   arg2 = (double)jarg2;
2751   {
2752     try {
2753       doublep_assign(arg1,arg2);
2754     } CALL_CATCH_EXCEPTION();
2755   }
2756
2757 }
2758
2759
2760 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_doublep_value(void * jarg1) {
2761   double jresult ;
2762   doublep *arg1 = (doublep *) 0 ;
2763   double result;
2764
2765   arg1 = (doublep *)jarg1;
2766   {
2767     try {
2768       result = (double)doublep_value(arg1);
2769     } CALL_CATCH_EXCEPTION(0);
2770   }
2771
2772   jresult = result;
2773   return jresult;
2774 }
2775
2776
2777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_cast(void * jarg1) {
2778   void * jresult ;
2779   doublep *arg1 = (doublep *) 0 ;
2780   double *result = 0 ;
2781
2782   arg1 = (doublep *)jarg1;
2783   {
2784     try {
2785       result = (double *)doublep_cast(arg1);
2786     } CALL_CATCH_EXCEPTION(0);
2787   }
2788
2789   jresult = (void *)result;
2790   return jresult;
2791 }
2792
2793
2794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_frompointer(void * jarg1) {
2795   void * jresult ;
2796   double *arg1 = (double *) 0 ;
2797   doublep *result = 0 ;
2798
2799   arg1 = (double *)jarg1;
2800   {
2801     try {
2802       result = (doublep *)doublep_frompointer(arg1);
2803     } CALL_CATCH_EXCEPTION(0);
2804   }
2805
2806   jresult = (void *)result;
2807   return jresult;
2808 }
2809
2810
2811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_uintp() {
2812   void * jresult ;
2813   uintp *result = 0 ;
2814
2815   {
2816     try {
2817       result = (uintp *)new_uintp();
2818     } CALL_CATCH_EXCEPTION(0);
2819   }
2820
2821   jresult = (void *)result;
2822   return jresult;
2823 }
2824
2825
2826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_uintp(void * jarg1) {
2827   uintp *arg1 = (uintp *) 0 ;
2828
2829   arg1 = (uintp *)jarg1;
2830   {
2831     try {
2832       delete_uintp(arg1);
2833     } CALL_CATCH_EXCEPTION();
2834   }
2835
2836 }
2837
2838
2839 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_uintp_assign(void * jarg1, unsigned int jarg2) {
2840   uintp *arg1 = (uintp *) 0 ;
2841   unsigned int arg2 ;
2842
2843   arg1 = (uintp *)jarg1;
2844   arg2 = (unsigned int)jarg2;
2845   {
2846     try {
2847       uintp_assign(arg1,arg2);
2848     } CALL_CATCH_EXCEPTION();
2849   }
2850
2851 }
2852
2853
2854 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_uintp_value(void * jarg1) {
2855   unsigned int jresult ;
2856   uintp *arg1 = (uintp *) 0 ;
2857   unsigned int result;
2858
2859   arg1 = (uintp *)jarg1;
2860   {
2861     try {
2862       result = (unsigned int)uintp_value(arg1);
2863     } CALL_CATCH_EXCEPTION(0);
2864   }
2865
2866   jresult = result;
2867   return jresult;
2868 }
2869
2870
2871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_cast(void * jarg1) {
2872   void * jresult ;
2873   uintp *arg1 = (uintp *) 0 ;
2874   unsigned int *result = 0 ;
2875
2876   arg1 = (uintp *)jarg1;
2877   {
2878     try {
2879       result = (unsigned int *)uintp_cast(arg1);
2880     } CALL_CATCH_EXCEPTION(0);
2881   }
2882
2883   jresult = (void *)result;
2884   return jresult;
2885 }
2886
2887
2888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_frompointer(void * jarg1) {
2889   void * jresult ;
2890   unsigned int *arg1 = (unsigned int *) 0 ;
2891   uintp *result = 0 ;
2892
2893   arg1 = (unsigned int *)jarg1;
2894   {
2895     try {
2896       result = (uintp *)uintp_frompointer(arg1);
2897     } CALL_CATCH_EXCEPTION(0);
2898   }
2899
2900   jresult = (void *)result;
2901   return jresult;
2902 }
2903
2904
2905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ushortp() {
2906   void * jresult ;
2907   ushortp *result = 0 ;
2908
2909   {
2910     try {
2911       result = (ushortp *)new_ushortp();
2912     } CALL_CATCH_EXCEPTION(0);
2913   }
2914
2915   jresult = (void *)result;
2916   return jresult;
2917 }
2918
2919
2920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ushortp(void * jarg1) {
2921   ushortp *arg1 = (ushortp *) 0 ;
2922
2923   arg1 = (ushortp *)jarg1;
2924   {
2925     try {
2926       delete_ushortp(arg1);
2927     } CALL_CATCH_EXCEPTION();
2928   }
2929
2930 }
2931
2932
2933 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ushortp_assign(void * jarg1, unsigned short jarg2) {
2934   ushortp *arg1 = (ushortp *) 0 ;
2935   unsigned short arg2 ;
2936
2937   arg1 = (ushortp *)jarg1;
2938   arg2 = (unsigned short)jarg2;
2939   {
2940     try {
2941       ushortp_assign(arg1,arg2);
2942     } CALL_CATCH_EXCEPTION();
2943   }
2944
2945 }
2946
2947
2948 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_ushortp_value(void * jarg1) {
2949   unsigned short jresult ;
2950   ushortp *arg1 = (ushortp *) 0 ;
2951   unsigned short result;
2952
2953   arg1 = (ushortp *)jarg1;
2954   {
2955     try {
2956       result = (unsigned short)ushortp_value(arg1);
2957     } CALL_CATCH_EXCEPTION(0);
2958   }
2959
2960   jresult = result;
2961   return jresult;
2962 }
2963
2964
2965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_cast(void * jarg1) {
2966   void * jresult ;
2967   ushortp *arg1 = (ushortp *) 0 ;
2968   unsigned short *result = 0 ;
2969
2970   arg1 = (ushortp *)jarg1;
2971   {
2972     try {
2973       result = (unsigned short *)ushortp_cast(arg1);
2974     } CALL_CATCH_EXCEPTION(0);
2975   }
2976
2977   jresult = (void *)result;
2978   return jresult;
2979 }
2980
2981
2982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_frompointer(void * jarg1) {
2983   void * jresult ;
2984   unsigned short *arg1 = (unsigned short *) 0 ;
2985   ushortp *result = 0 ;
2986
2987   arg1 = (unsigned short *)jarg1;
2988   {
2989     try {
2990       result = (ushortp *)ushortp_frompointer(arg1);
2991     } CALL_CATCH_EXCEPTION(0);
2992   }
2993
2994   jresult = (void *)result;
2995   return jresult;
2996 }
2997
2998
2999 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_int_to_uint(int jarg1) {
3000   unsigned int jresult ;
3001   int arg1 ;
3002   unsigned int result;
3003
3004   arg1 = (int)jarg1;
3005   {
3006     try {
3007       result = (unsigned int)int_to_uint(arg1);
3008     } CALL_CATCH_EXCEPTION(0);
3009   }
3010
3011   jresult = result;
3012   return jresult;
3013 }
3014
3015
3016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Reference(void * jarg1) {
3017   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3018
3019   arg1 = (Dali::RefObject *)jarg1;
3020   {
3021     try {
3022       (arg1)->Reference();
3023     } CALL_CATCH_EXCEPTION();
3024   }
3025
3026 }
3027
3028
3029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Unreference(void * jarg1) {
3030   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3031
3032   arg1 = (Dali::RefObject *)jarg1;
3033   {
3034     try {
3035       (arg1)->Unreference();
3036     } CALL_CATCH_EXCEPTION();
3037   }
3038
3039 }
3040
3041
3042 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RefObject_ReferenceCount(void * jarg1) {
3043   int jresult ;
3044   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3045   int result;
3046
3047   arg1 = (Dali::RefObject *)jarg1;
3048   {
3049     try {
3050       result = (int)(arg1)->ReferenceCount();
3051     } CALL_CATCH_EXCEPTION(0);
3052   }
3053
3054   jresult = result;
3055   return jresult;
3056 }
3057
3058
3059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_0() {
3060   void * jresult ;
3061   Dali::Any *result = 0 ;
3062
3063   {
3064     try {
3065       result = (Dali::Any *)new Dali::Any();
3066     } CALL_CATCH_EXCEPTION(0);
3067   }
3068
3069   jresult = (void *)result;
3070   return jresult;
3071 }
3072
3073
3074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any(void * jarg1) {
3075   Dali::Any *arg1 = (Dali::Any *) 0 ;
3076
3077   arg1 = (Dali::Any *)jarg1;
3078   {
3079     try {
3080       delete arg1;
3081     } CALL_CATCH_EXCEPTION();
3082   }
3083
3084 }
3085
3086
3087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AssertAlways(char * jarg1) {
3088   char *arg1 = (char *) 0 ;
3089
3090   arg1 = (char *)jarg1;
3091   {
3092     try {
3093       Dali::Any::AssertAlways((char const *)arg1);
3094     } CALL_CATCH_EXCEPTION();
3095   }
3096
3097 }
3098
3099
3100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_2(void * jarg1) {
3101   void * jresult ;
3102   Dali::Any *arg1 = 0 ;
3103   Dali::Any *result = 0 ;
3104
3105   arg1 = (Dali::Any *)jarg1;
3106   if (!arg1) {
3107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3108     return 0;
3109   }
3110   {
3111     try {
3112       result = (Dali::Any *)new Dali::Any((Dali::Any const &)*arg1);
3113     } CALL_CATCH_EXCEPTION(0);
3114   }
3115
3116   jresult = (void *)result;
3117   return jresult;
3118 }
3119
3120
3121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_Assign(void * jarg1, void * jarg2) {
3122   void * jresult ;
3123   Dali::Any *arg1 = (Dali::Any *) 0 ;
3124   Dali::Any *arg2 = 0 ;
3125   Dali::Any *result = 0 ;
3126
3127   arg1 = (Dali::Any *)jarg1;
3128   arg2 = (Dali::Any *)jarg2;
3129   if (!arg2) {
3130     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3131     return 0;
3132   }
3133   {
3134     try {
3135       result = (Dali::Any *) &(arg1)->operator =((Dali::Any const &)*arg2);
3136     } CALL_CATCH_EXCEPTION(0);
3137   }
3138
3139   jresult = (void *)result;
3140   return jresult;
3141 }
3142
3143
3144 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_GetType(void * jarg1) {
3145   void * jresult ;
3146   Dali::Any *arg1 = (Dali::Any *) 0 ;
3147   std::type_info *result = 0 ;
3148
3149   arg1 = (Dali::Any *)jarg1;
3150   {
3151     try {
3152       result = (std::type_info *) &((Dali::Any const *)arg1)->GetType();
3153     } CALL_CATCH_EXCEPTION(0);
3154   }
3155
3156   jresult = (void *)result;
3157   return jresult;
3158 }
3159
3160
3161 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Any_Empty(void * jarg1) {
3162   unsigned int jresult ;
3163   Dali::Any *arg1 = (Dali::Any *) 0 ;
3164   bool result;
3165
3166   arg1 = (Dali::Any *)jarg1;
3167   {
3168     try {
3169       result = (bool)((Dali::Any const *)arg1)->Empty();
3170     } CALL_CATCH_EXCEPTION(0);
3171   }
3172
3173   jresult = result;
3174   return jresult;
3175 }
3176
3177
3178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any_AnyContainerBase(void * jarg1, void * jarg2, void * jarg3) {
3179   void * jresult ;
3180   std::type_info *arg1 = 0 ;
3181   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3182   Dali::Any::DeleteFunc arg3 = (Dali::Any::DeleteFunc) 0 ;
3183   Dali::Any::AnyContainerBase *result = 0 ;
3184
3185   arg1 = (std::type_info *)jarg1;
3186   if (!arg1) {
3187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
3188     return 0;
3189   }
3190   arg2 = (Dali::Any::CloneFunc)jarg2;
3191   arg3 = (Dali::Any::DeleteFunc)jarg3;
3192   {
3193     try {
3194       result = (Dali::Any::AnyContainerBase *)new Dali::Any::AnyContainerBase((std::type_info const &)*arg1,arg2,arg3);
3195     } CALL_CATCH_EXCEPTION(0);
3196   }
3197
3198   jresult = (void *)result;
3199   return jresult;
3200 }
3201
3202
3203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_GetType(void * jarg1) {
3204   void * jresult ;
3205   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3206   std::type_info *result = 0 ;
3207
3208   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3209   {
3210     try {
3211       result = (std::type_info *) &((Dali::Any::AnyContainerBase const *)arg1)->GetType();
3212     } CALL_CATCH_EXCEPTION(0);
3213   }
3214
3215   jresult = (void *)result;
3216   return jresult;
3217 }
3218
3219
3220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mType_get(void * jarg1) {
3221   void * jresult ;
3222   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3223   ::std::type_info *result = 0 ;
3224
3225   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3226   result = (::std::type_info *) &(::std::type_info const &) ((arg1)->mType);
3227   jresult = (void *)result;
3228   return jresult;
3229 }
3230
3231
3232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_set(void * jarg1, void * jarg2) {
3233   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3234   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3235
3236   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3237   arg2 = (Dali::Any::CloneFunc)jarg2;
3238   if (arg1) (arg1)->mCloneFunc = arg2;
3239 }
3240
3241
3242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_get(void * jarg1) {
3243   void * jresult ;
3244   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3245   Dali::Any::CloneFunc result;
3246
3247   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3248   result = (Dali::Any::CloneFunc) ((arg1)->mCloneFunc);
3249   jresult = (void *)result;
3250   return jresult;
3251 }
3252
3253
3254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_set(void * jarg1, void * jarg2) {
3255   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3256   Dali::Any::DeleteFunc arg2 = (Dali::Any::DeleteFunc) 0 ;
3257
3258   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3259   arg2 = (Dali::Any::DeleteFunc)jarg2;
3260   if (arg1) (arg1)->mDeleteFunc = arg2;
3261 }
3262
3263
3264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_get(void * jarg1) {
3265   void * jresult ;
3266   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3267   Dali::Any::DeleteFunc result;
3268
3269   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3270   result = (Dali::Any::DeleteFunc) ((arg1)->mDeleteFunc);
3271   jresult = (void *)result;
3272   return jresult;
3273 }
3274
3275
3276 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any_AnyContainerBase(void * jarg1) {
3277   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3278
3279   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3280   {
3281     try {
3282       delete arg1;
3283     } CALL_CATCH_EXCEPTION();
3284   }
3285
3286 }
3287
3288
3289 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_mContainer_set(void * jarg1, void * jarg2) {
3290   Dali::Any *arg1 = (Dali::Any *) 0 ;
3291   Dali::Any::AnyContainerBase *arg2 = (Dali::Any::AnyContainerBase *) 0 ;
3292
3293   arg1 = (Dali::Any *)jarg1;
3294   arg2 = (Dali::Any::AnyContainerBase *)jarg2;
3295   if (arg1) (arg1)->mContainer = arg2;
3296 }
3297
3298
3299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_mContainer_get(void * jarg1) {
3300   void * jresult ;
3301   Dali::Any *arg1 = (Dali::Any *) 0 ;
3302   Dali::Any::AnyContainerBase *result = 0 ;
3303
3304   arg1 = (Dali::Any *)jarg1;
3305   result = (Dali::Any::AnyContainerBase *) ((arg1)->mContainer);
3306   jresult = (void *)result;
3307   return jresult;
3308 }
3309
3310
3311 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliAssertMessage(char * jarg1, char * jarg2) {
3312   char *arg1 = (char *) 0 ;
3313   char *arg2 = (char *) 0 ;
3314
3315   arg1 = (char *)jarg1;
3316   arg2 = (char *)jarg2;
3317   {
3318     try {
3319       Dali::DaliAssertMessage((char const *)arg1,(char const *)arg2);
3320     } CALL_CATCH_EXCEPTION();
3321   }
3322
3323 }
3324
3325
3326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DaliException(char * jarg1, char * jarg2) {
3327   void * jresult ;
3328   char *arg1 = (char *) 0 ;
3329   char *arg2 = (char *) 0 ;
3330   Dali::DaliException *result = 0 ;
3331
3332   arg1 = (char *)jarg1;
3333   arg2 = (char *)jarg2;
3334   {
3335     try {
3336       result = (Dali::DaliException *)new Dali::DaliException((char const *)arg1,(char const *)arg2);
3337     } CALL_CATCH_EXCEPTION(0);
3338   }
3339
3340   jresult = (void *)result;
3341   return jresult;
3342 }
3343
3344
3345 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_location_set(void * jarg1, char * jarg2) {
3346   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3347   std::string arg2 = std::string(jarg2);
3348
3349   arg1 = (Dali::DaliException *)jarg1;
3350   {
3351     if (!arg2.empty()) {
3352       ((char *)(arg1->location))[arg2.copy((char*)(arg1->location), strlen(arg1->location)-1)] = '\0';
3353     } else {
3354       arg1->location = 0;
3355     }
3356   }
3357 }
3358
3359 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_location_get(void * jarg1) {
3360   char * jresult ;
3361   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3362   char *result = 0 ;
3363
3364   arg1 = (Dali::DaliException *)jarg1;
3365   result = (char *) ((arg1)->location);
3366   jresult = SWIG_csharp_string_callback((const char *)result);
3367   return jresult;
3368 }
3369
3370
3371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_condition_set(void * jarg1, char * jarg2) {
3372   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3373   std::string arg2 = std::string(jarg2);
3374
3375   arg1 = (Dali::DaliException *)jarg1;
3376   {
3377     if (!arg2.empty()) {
3378       ((char *)(arg1->condition))[arg2.copy((char*)(arg1->condition), strlen(arg1->condition)-1)] = '\0';
3379     } else {
3380       arg1->condition = 0;
3381     }
3382   }
3383 }
3384
3385
3386 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_condition_get(void * jarg1) {
3387   char * jresult ;
3388   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3389   char *result = 0 ;
3390
3391   arg1 = (Dali::DaliException *)jarg1;
3392   result = (char *) ((arg1)->condition);
3393   jresult = SWIG_csharp_string_callback((const char *)result);
3394   return jresult;
3395 }
3396
3397
3398 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DaliException(void * jarg1) {
3399   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3400
3401   arg1 = (Dali::DaliException *)jarg1;
3402   {
3403     try {
3404       delete arg1;
3405     } CALL_CATCH_EXCEPTION();
3406   }
3407
3408 }
3409
3410
3411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_0() {
3412   void * jresult ;
3413   Dali::Vector2 *result = 0 ;
3414
3415   {
3416     try {
3417       result = (Dali::Vector2 *)new Dali::Vector2();
3418     } CALL_CATCH_EXCEPTION(0);
3419   }
3420
3421   jresult = (void *)result;
3422   return jresult;
3423 }
3424
3425
3426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_1(float jarg1, float jarg2) {
3427   void * jresult ;
3428   float arg1 ;
3429   float arg2 ;
3430   Dali::Vector2 *result = 0 ;
3431
3432   arg1 = (float)jarg1;
3433   arg2 = (float)jarg2;
3434   {
3435     try {
3436       result = (Dali::Vector2 *)new Dali::Vector2(arg1,arg2);
3437     } CALL_CATCH_EXCEPTION(0);
3438   }
3439
3440   jresult = (void *)result;
3441   return jresult;
3442 }
3443
3444
3445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_2(float* jarg1) {
3446   void * jresult ;
3447   float *arg1 = (float *) 0 ;
3448   Dali::Vector2 *result = 0 ;
3449
3450   arg1 = jarg1;
3451   {
3452     try {
3453       result = (Dali::Vector2 *)new Dali::Vector2((float const *)arg1);
3454     } CALL_CATCH_EXCEPTION(0);
3455   }
3456
3457   jresult = (void *)result;
3458
3459
3460   return jresult;
3461 }
3462
3463
3464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_3(void * jarg1) {
3465   void * jresult ;
3466   Dali::Vector3 *arg1 = 0 ;
3467   Dali::Vector2 *result = 0 ;
3468
3469   arg1 = (Dali::Vector3 *)jarg1;
3470   if (!arg1) {
3471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
3472     return 0;
3473   }
3474   {
3475     try {
3476       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector3 const &)*arg1);
3477     } CALL_CATCH_EXCEPTION(0);
3478   }
3479
3480   jresult = (void *)result;
3481   return jresult;
3482 }
3483
3484
3485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_4(void * jarg1) {
3486   void * jresult ;
3487   Dali::Vector4 *arg1 = 0 ;
3488   Dali::Vector2 *result = 0 ;
3489
3490   arg1 = (Dali::Vector4 *)jarg1;
3491   if (!arg1) {
3492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
3493     return 0;
3494   }
3495   {
3496     try {
3497       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector4 const &)*arg1);
3498     } CALL_CATCH_EXCEPTION(0);
3499   }
3500
3501   jresult = (void *)result;
3502   return jresult;
3503 }
3504
3505
3506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ONE_get() {
3507   void * jresult ;
3508   Dali::Vector2 *result = 0 ;
3509
3510   result = (Dali::Vector2 *)&Dali::Vector2::ONE;
3511   jresult = (void *)result;
3512   return jresult;
3513 }
3514
3515
3516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_XAXIS_get() {
3517   void * jresult ;
3518   Dali::Vector2 *result = 0 ;
3519
3520   result = (Dali::Vector2 *)&Dali::Vector2::XAXIS;
3521   jresult = (void *)result;
3522   return jresult;
3523 }
3524
3525
3526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_YAXIS_get() {
3527   void * jresult ;
3528   Dali::Vector2 *result = 0 ;
3529
3530   result = (Dali::Vector2 *)&Dali::Vector2::YAXIS;
3531   jresult = (void *)result;
3532   return jresult;
3533 }
3534
3535
3536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_XAXIS_get() {
3537   void * jresult ;
3538   Dali::Vector2 *result = 0 ;
3539
3540   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_XAXIS;
3541   jresult = (void *)result;
3542   return jresult;
3543 }
3544
3545
3546 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_YAXIS_get() {
3547   void * jresult ;
3548   Dali::Vector2 *result = 0 ;
3549
3550   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_YAXIS;
3551   jresult = (void *)result;
3552   return jresult;
3553 }
3554
3555
3556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ZERO_get() {
3557   void * jresult ;
3558   Dali::Vector2 *result = 0 ;
3559
3560   result = (Dali::Vector2 *)&Dali::Vector2::ZERO;
3561   jresult = (void *)result;
3562   return jresult;
3563 }
3564
3565
3566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_0(void * jarg1, float* jarg2) {
3567   void * jresult ;
3568   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3569   float *arg2 = (float *) 0 ;
3570   Dali::Vector2 *result = 0 ;
3571
3572   arg1 = (Dali::Vector2 *)jarg1;
3573   arg2 = jarg2;
3574   {
3575     try {
3576       result = (Dali::Vector2 *) &(arg1)->operator =((float const *)arg2);
3577     } CALL_CATCH_EXCEPTION(0);
3578   }
3579
3580   jresult = (void *)result;
3581
3582
3583   return jresult;
3584 }
3585
3586
3587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_1(void * jarg1, void * jarg2) {
3588   void * jresult ;
3589   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3590   Dali::Vector3 *arg2 = 0 ;
3591   Dali::Vector2 *result = 0 ;
3592
3593   arg1 = (Dali::Vector2 *)jarg1;
3594   arg2 = (Dali::Vector3 *)jarg2;
3595   if (!arg2) {
3596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
3597     return 0;
3598   }
3599   {
3600     try {
3601       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
3602     } CALL_CATCH_EXCEPTION(0);
3603   }
3604
3605   jresult = (void *)result;
3606   return jresult;
3607 }
3608
3609
3610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_2(void * jarg1, void * jarg2) {
3611   void * jresult ;
3612   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3613   Dali::Vector4 *arg2 = 0 ;
3614   Dali::Vector2 *result = 0 ;
3615
3616   arg1 = (Dali::Vector2 *)jarg1;
3617   arg2 = (Dali::Vector4 *)jarg2;
3618   if (!arg2) {
3619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
3620     return 0;
3621   }
3622   {
3623     try {
3624       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
3625     } CALL_CATCH_EXCEPTION(0);
3626   }
3627
3628   jresult = (void *)result;
3629   return jresult;
3630 }
3631
3632
3633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Add(void * jarg1, void * jarg2) {
3634   void * jresult ;
3635   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3636   Dali::Vector2 *arg2 = 0 ;
3637   Dali::Vector2 result;
3638
3639   arg1 = (Dali::Vector2 *)jarg1;
3640   arg2 = (Dali::Vector2 *)jarg2;
3641   if (!arg2) {
3642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3643     return 0;
3644   }
3645   {
3646     try {
3647       result = ((Dali::Vector2 const *)arg1)->operator +((Dali::Vector2 const &)*arg2);
3648     } CALL_CATCH_EXCEPTION(0);
3649   }
3650
3651   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
3652   return jresult;
3653 }
3654
3655
3656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AddAssign(void * jarg1, void * jarg2) {
3657   void * jresult ;
3658   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3659   Dali::Vector2 *arg2 = 0 ;
3660   Dali::Vector2 *result = 0 ;
3661
3662   arg1 = (Dali::Vector2 *)jarg1;
3663   arg2 = (Dali::Vector2 *)jarg2;
3664   if (!arg2) {
3665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3666     return 0;
3667   }
3668   {
3669     try {
3670       result = (Dali::Vector2 *) &(arg1)->operator +=((Dali::Vector2 const &)*arg2);
3671     } CALL_CATCH_EXCEPTION(0);
3672   }
3673
3674   jresult = (void *)result;
3675   return jresult;
3676 }
3677
3678
3679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_0(void * jarg1, void * jarg2) {
3680   void * jresult ;
3681   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3682   Dali::Vector2 *arg2 = 0 ;
3683   Dali::Vector2 result;
3684
3685   arg1 = (Dali::Vector2 *)jarg1;
3686   arg2 = (Dali::Vector2 *)jarg2;
3687   if (!arg2) {
3688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3689     return 0;
3690   }
3691   {
3692     try {
3693       result = ((Dali::Vector2 const *)arg1)->operator -((Dali::Vector2 const &)*arg2);
3694     } CALL_CATCH_EXCEPTION(0);
3695   }
3696
3697   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
3698   return jresult;
3699 }
3700
3701
3702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_SubtractAssign(void * jarg1, void * jarg2) {
3703   void * jresult ;
3704   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3705   Dali::Vector2 *arg2 = 0 ;
3706   Dali::Vector2 *result = 0 ;
3707
3708   arg1 = (Dali::Vector2 *)jarg1;
3709   arg2 = (Dali::Vector2 *)jarg2;
3710   if (!arg2) {
3711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3712     return 0;
3713   }
3714   {
3715     try {
3716       result = (Dali::Vector2 *) &(arg1)->operator -=((Dali::Vector2 const &)*arg2);
3717     } CALL_CATCH_EXCEPTION(0);
3718   }
3719
3720   jresult = (void *)result;
3721   return jresult;
3722 }
3723
3724
3725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_0(void * jarg1, void * jarg2) {
3726   void * jresult ;
3727   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3728   Dali::Vector2 *arg2 = 0 ;
3729   Dali::Vector2 result;
3730
3731   arg1 = (Dali::Vector2 *)jarg1;
3732   arg2 = (Dali::Vector2 *)jarg2;
3733   if (!arg2) {
3734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3735     return 0;
3736   }
3737   {
3738     try {
3739       result = ((Dali::Vector2 const *)arg1)->operator *((Dali::Vector2 const &)*arg2);
3740     } CALL_CATCH_EXCEPTION(0);
3741   }
3742
3743   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
3744   return jresult;
3745 }
3746
3747
3748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_1(void * jarg1, float jarg2) {
3749   void * jresult ;
3750   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3751   float arg2 ;
3752   Dali::Vector2 result;
3753
3754   arg1 = (Dali::Vector2 *)jarg1;
3755   arg2 = (float)jarg2;
3756   {
3757     try {
3758       result = ((Dali::Vector2 const *)arg1)->operator *(arg2);
3759     } CALL_CATCH_EXCEPTION(0);
3760   }
3761
3762   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
3763   return jresult;
3764 }
3765
3766
3767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
3768   void * jresult ;
3769   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3770   Dali::Vector2 *arg2 = 0 ;
3771   Dali::Vector2 *result = 0 ;
3772
3773   arg1 = (Dali::Vector2 *)jarg1;
3774   arg2 = (Dali::Vector2 *)jarg2;
3775   if (!arg2) {
3776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3777     return 0;
3778   }
3779   {
3780     try {
3781       result = (Dali::Vector2 *) &(arg1)->operator *=((Dali::Vector2 const &)*arg2);
3782     } CALL_CATCH_EXCEPTION(0);
3783   }
3784
3785   jresult = (void *)result;
3786   return jresult;
3787 }
3788
3789
3790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
3791   void * jresult ;
3792   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3793   float arg2 ;
3794   Dali::Vector2 *result = 0 ;
3795
3796   arg1 = (Dali::Vector2 *)jarg1;
3797   arg2 = (float)jarg2;
3798   {
3799     try {
3800       result = (Dali::Vector2 *) &(arg1)->operator *=(arg2);
3801     } CALL_CATCH_EXCEPTION(0);
3802   }
3803
3804   jresult = (void *)result;
3805   return jresult;
3806 }
3807
3808
3809 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_0(void * jarg1, void * jarg2) {
3810   void * jresult ;
3811   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3812   Dali::Vector2 *arg2 = 0 ;
3813   Dali::Vector2 result;
3814
3815   arg1 = (Dali::Vector2 *)jarg1;
3816   arg2 = (Dali::Vector2 *)jarg2;
3817   if (!arg2) {
3818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3819     return 0;
3820   }
3821   {
3822     try {
3823       result = ((Dali::Vector2 const *)arg1)->operator /((Dali::Vector2 const &)*arg2);
3824     } CALL_CATCH_EXCEPTION(0);
3825   }
3826
3827   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
3828   return jresult;
3829 }
3830
3831
3832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_1(void * jarg1, float jarg2) {
3833   void * jresult ;
3834   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3835   float arg2 ;
3836   Dali::Vector2 result;
3837
3838   arg1 = (Dali::Vector2 *)jarg1;
3839   arg2 = (float)jarg2;
3840   {
3841     try {
3842       result = ((Dali::Vector2 const *)arg1)->operator /(arg2);
3843     } CALL_CATCH_EXCEPTION(0);
3844   }
3845
3846   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
3847   return jresult;
3848 }
3849
3850
3851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
3852   void * jresult ;
3853   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3854   Dali::Vector2 *arg2 = 0 ;
3855   Dali::Vector2 *result = 0 ;
3856
3857   arg1 = (Dali::Vector2 *)jarg1;
3858   arg2 = (Dali::Vector2 *)jarg2;
3859   if (!arg2) {
3860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3861     return 0;
3862   }
3863   {
3864     try {
3865       result = (Dali::Vector2 *) &(arg1)->operator /=((Dali::Vector2 const &)*arg2);
3866     } CALL_CATCH_EXCEPTION(0);
3867   }
3868
3869   jresult = (void *)result;
3870   return jresult;
3871 }
3872
3873
3874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
3875   void * jresult ;
3876   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3877   float arg2 ;
3878   Dali::Vector2 *result = 0 ;
3879
3880   arg1 = (Dali::Vector2 *)jarg1;
3881   arg2 = (float)jarg2;
3882   {
3883     try {
3884       result = (Dali::Vector2 *) &(arg1)->operator /=(arg2);
3885     } CALL_CATCH_EXCEPTION(0);
3886   }
3887
3888   jresult = (void *)result;
3889   return jresult;
3890 }
3891
3892
3893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_1(void * jarg1) {
3894   void * jresult ;
3895   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3896   Dali::Vector2 result;
3897
3898   arg1 = (Dali::Vector2 *)jarg1;
3899   {
3900     try {
3901       result = ((Dali::Vector2 const *)arg1)->operator -();
3902     } CALL_CATCH_EXCEPTION(0);
3903   }
3904
3905   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
3906   return jresult;
3907 }
3908
3909
3910 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_EqualTo(void * jarg1, void * jarg2) {
3911   unsigned int jresult ;
3912   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3913   Dali::Vector2 *arg2 = 0 ;
3914   bool result;
3915
3916   arg1 = (Dali::Vector2 *)jarg1;
3917   arg2 = (Dali::Vector2 *)jarg2;
3918   if (!arg2) {
3919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3920     return 0;
3921   }
3922   {
3923     try {
3924       result = (bool)((Dali::Vector2 const *)arg1)->operator ==((Dali::Vector2 const &)*arg2);
3925     } CALL_CATCH_EXCEPTION(0);
3926   }
3927
3928   jresult = result;
3929   return jresult;
3930 }
3931
3932
3933 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_NotEqualTo(void * jarg1, void * jarg2) {
3934   unsigned int jresult ;
3935   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3936   Dali::Vector2 *arg2 = 0 ;
3937   bool result;
3938
3939   arg1 = (Dali::Vector2 *)jarg1;
3940   arg2 = (Dali::Vector2 *)jarg2;
3941   if (!arg2) {
3942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3943     return 0;
3944   }
3945   {
3946     try {
3947       result = (bool)((Dali::Vector2 const *)arg1)->operator !=((Dali::Vector2 const &)*arg2);
3948     } CALL_CATCH_EXCEPTION(0);
3949   }
3950
3951   jresult = result;
3952   return jresult;
3953 }
3954
3955
3956 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
3957   float jresult ;
3958   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3959   unsigned int arg2 ;
3960   float *result = 0 ;
3961
3962   arg1 = (Dali::Vector2 *)jarg1;
3963   arg2 = (unsigned int)jarg2;
3964   {
3965     try {
3966       result = (float *) &((Dali::Vector2 const *)arg1)->operator [](arg2);
3967     } CALL_CATCH_EXCEPTION(0);
3968   }
3969
3970   jresult = *result;
3971   return jresult;
3972 }
3973
3974
3975 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Length(void * jarg1) {
3976   float jresult ;
3977   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3978   float result;
3979
3980   arg1 = (Dali::Vector2 *)jarg1;
3981   {
3982     try {
3983       result = (float)((Dali::Vector2 const *)arg1)->Length();
3984     } CALL_CATCH_EXCEPTION(0);
3985   }
3986
3987   jresult = result;
3988   return jresult;
3989 }
3990
3991
3992 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_LengthSquared(void * jarg1) {
3993   float jresult ;
3994   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3995   float result;
3996
3997   arg1 = (Dali::Vector2 *)jarg1;
3998   {
3999     try {
4000       result = (float)((Dali::Vector2 const *)arg1)->LengthSquared();
4001     } CALL_CATCH_EXCEPTION(0);
4002   }
4003
4004   jresult = result;
4005   return jresult;
4006 }
4007
4008
4009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Normalize(void * jarg1) {
4010   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4011
4012   arg1 = (Dali::Vector2 *)jarg1;
4013   {
4014     try {
4015       (arg1)->Normalize();
4016     } CALL_CATCH_EXCEPTION();
4017   }
4018
4019 }
4020
4021
4022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Clamp(void * jarg1, void * jarg2, void * jarg3) {
4023   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4024   Dali::Vector2 *arg2 = 0 ;
4025   Dali::Vector2 *arg3 = 0 ;
4026
4027   arg1 = (Dali::Vector2 *)jarg1;
4028   arg2 = (Dali::Vector2 *)jarg2;
4029   if (!arg2) {
4030     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4031     return ;
4032   }
4033   arg3 = (Dali::Vector2 *)jarg3;
4034   if (!arg3) {
4035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4036     return ;
4037   }
4038   {
4039     try {
4040       (arg1)->Clamp((Dali::Vector2 const &)*arg2,(Dali::Vector2 const &)*arg3);
4041     } CALL_CATCH_EXCEPTION();
4042   }
4043
4044 }
4045
4046
4047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AsFloat__SWIG_0(void * jarg1) {
4048   void * jresult ;
4049   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4050   float *result = 0 ;
4051
4052   arg1 = (Dali::Vector2 *)jarg1;
4053   {
4054     try {
4055       result = (float *)((Dali::Vector2 const *)arg1)->AsFloat();
4056     } CALL_CATCH_EXCEPTION(0);
4057   }
4058
4059   jresult = (void *)result;
4060   return jresult;
4061 }
4062
4063
4064 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_X_set(void * jarg1, float jarg2) {
4065   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4066   float arg2 ;
4067
4068   arg1 = (Dali::Vector2 *)jarg1;
4069   arg2 = (float)jarg2;
4070   if (arg1) (arg1)->x = arg2;
4071 }
4072
4073
4074 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_X_get(void * jarg1) {
4075   float jresult ;
4076   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4077   float result;
4078
4079   arg1 = (Dali::Vector2 *)jarg1;
4080   result = (float) ((arg1)->x);
4081   jresult = result;
4082   return jresult;
4083 }
4084
4085
4086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Width_set(void * jarg1, float jarg2) {
4087   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4088   float arg2 ;
4089
4090   arg1 = (Dali::Vector2 *)jarg1;
4091   arg2 = (float)jarg2;
4092   if (arg1) (arg1)->width = arg2;
4093 }
4094
4095
4096 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Width_get(void * jarg1) {
4097   float jresult ;
4098   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4099   float result;
4100
4101   arg1 = (Dali::Vector2 *)jarg1;
4102   result = (float) ((arg1)->width);
4103   jresult = result;
4104   return jresult;
4105 }
4106
4107
4108 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Y_set(void * jarg1, float jarg2) {
4109   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4110   float arg2 ;
4111
4112   arg1 = (Dali::Vector2 *)jarg1;
4113   arg2 = (float)jarg2;
4114   if (arg1) (arg1)->y = arg2;
4115 }
4116
4117
4118 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Y_get(void * jarg1) {
4119   float jresult ;
4120   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4121   float result;
4122
4123   arg1 = (Dali::Vector2 *)jarg1;
4124   result = (float) ((arg1)->y);
4125   jresult = result;
4126   return jresult;
4127 }
4128
4129
4130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Height_set(void * jarg1, float jarg2) {
4131   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4132   float arg2 ;
4133
4134   arg1 = (Dali::Vector2 *)jarg1;
4135   arg2 = (float)jarg2;
4136   if (arg1) (arg1)->height = arg2;
4137 }
4138
4139
4140 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Height_get(void * jarg1) {
4141   float jresult ;
4142   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4143   float result;
4144
4145   arg1 = (Dali::Vector2 *)jarg1;
4146   result = (float) ((arg1)->height);
4147   jresult = result;
4148   return jresult;
4149 }
4150
4151
4152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector2(void * jarg1) {
4153   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4154
4155   arg1 = (Dali::Vector2 *)jarg1;
4156   {
4157     try {
4158       delete arg1;
4159     } CALL_CATCH_EXCEPTION();
4160   }
4161
4162 }
4163
4164
4165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_0(void * jarg1, void * jarg2) {
4166   void * jresult ;
4167   Dali::Vector2 *arg1 = 0 ;
4168   Dali::Vector2 *arg2 = 0 ;
4169   Dali::Vector2 result;
4170
4171   arg1 = (Dali::Vector2 *)jarg1;
4172   if (!arg1) {
4173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4174     return 0;
4175   }
4176   arg2 = (Dali::Vector2 *)jarg2;
4177   if (!arg2) {
4178     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4179     return 0;
4180   }
4181   {
4182     try {
4183       result = Dali::Min((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
4184     } CALL_CATCH_EXCEPTION(0);
4185   }
4186
4187   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4188   return jresult;
4189 }
4190
4191
4192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_0(void * jarg1, void * jarg2) {
4193   void * jresult ;
4194   Dali::Vector2 *arg1 = 0 ;
4195   Dali::Vector2 *arg2 = 0 ;
4196   Dali::Vector2 result;
4197
4198   arg1 = (Dali::Vector2 *)jarg1;
4199   if (!arg1) {
4200     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4201     return 0;
4202   }
4203   arg2 = (Dali::Vector2 *)jarg2;
4204   if (!arg2) {
4205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4206     return 0;
4207   }
4208   {
4209     try {
4210       result = Dali::Max((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
4211     } CALL_CATCH_EXCEPTION(0);
4212   }
4213
4214   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4215   return jresult;
4216 }
4217
4218
4219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3) {
4220   void * jresult ;
4221   Dali::Vector2 *arg1 = 0 ;
4222   float *arg2 = 0 ;
4223   float *arg3 = 0 ;
4224   float temp2 ;
4225   float temp3 ;
4226   Dali::Vector2 result;
4227
4228   arg1 = (Dali::Vector2 *)jarg1;
4229   if (!arg1) {
4230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4231     return 0;
4232   }
4233   temp2 = (float)jarg2;
4234   arg2 = &temp2;
4235   temp3 = (float)jarg3;
4236   arg3 = &temp3;
4237   {
4238     try {
4239       result = Dali::Clamp((Dali::Vector2 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
4240     } CALL_CATCH_EXCEPTION(0);
4241   }
4242
4243   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4244   return jresult;
4245 }
4246
4247
4248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_0() {
4249   void * jresult ;
4250   Dali::Vector3 *result = 0 ;
4251
4252   {
4253     try {
4254       result = (Dali::Vector3 *)new Dali::Vector3();
4255     } CALL_CATCH_EXCEPTION(0);
4256   }
4257
4258   jresult = (void *)result;
4259   return jresult;
4260 }
4261
4262
4263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_1(float jarg1, float jarg2, float jarg3) {
4264   void * jresult ;
4265   float arg1 ;
4266   float arg2 ;
4267   float arg3 ;
4268   Dali::Vector3 *result = 0 ;
4269
4270   arg1 = (float)jarg1;
4271   arg2 = (float)jarg2;
4272   arg3 = (float)jarg3;
4273   {
4274     try {
4275       result = (Dali::Vector3 *)new Dali::Vector3(arg1,arg2,arg3);
4276     } CALL_CATCH_EXCEPTION(0);
4277   }
4278
4279   jresult = (void *)result;
4280   return jresult;
4281 }
4282
4283
4284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_2(float* jarg1) {
4285   void * jresult ;
4286   float *arg1 = (float *) 0 ;
4287   Dali::Vector3 *result = 0 ;
4288
4289   arg1 = jarg1;
4290   {
4291     try {
4292       result = (Dali::Vector3 *)new Dali::Vector3((float const *)arg1);
4293     } CALL_CATCH_EXCEPTION(0);
4294   }
4295
4296   jresult = (void *)result;
4297
4298
4299   return jresult;
4300 }
4301
4302
4303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_3(void * jarg1) {
4304   void * jresult ;
4305   Dali::Vector2 *arg1 = 0 ;
4306   Dali::Vector3 *result = 0 ;
4307
4308   arg1 = (Dali::Vector2 *)jarg1;
4309   if (!arg1) {
4310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4311     return 0;
4312   }
4313   {
4314     try {
4315       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector2 const &)*arg1);
4316     } CALL_CATCH_EXCEPTION(0);
4317   }
4318
4319   jresult = (void *)result;
4320   return jresult;
4321 }
4322
4323
4324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_4(void * jarg1) {
4325   void * jresult ;
4326   Dali::Vector4 *arg1 = 0 ;
4327   Dali::Vector3 *result = 0 ;
4328
4329   arg1 = (Dali::Vector4 *)jarg1;
4330   if (!arg1) {
4331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4332     return 0;
4333   }
4334   {
4335     try {
4336       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector4 const &)*arg1);
4337     } CALL_CATCH_EXCEPTION(0);
4338   }
4339
4340   jresult = (void *)result;
4341   return jresult;
4342 }
4343
4344
4345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ONE_get() {
4346   void * jresult ;
4347   Dali::Vector3 *result = 0 ;
4348
4349   result = (Dali::Vector3 *)&Dali::Vector3::ONE;
4350   jresult = (void *)result;
4351   return jresult;
4352 }
4353
4354
4355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_XAXIS_get() {
4356   void * jresult ;
4357   Dali::Vector3 *result = 0 ;
4358
4359   result = (Dali::Vector3 *)&Dali::Vector3::XAXIS;
4360   jresult = (void *)result;
4361   return jresult;
4362 }
4363
4364
4365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_YAXIS_get() {
4366   void * jresult ;
4367   Dali::Vector3 *result = 0 ;
4368
4369   result = (Dali::Vector3 *)&Dali::Vector3::YAXIS;
4370   jresult = (void *)result;
4371   return jresult;
4372 }
4373
4374
4375 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZAXIS_get() {
4376   void * jresult ;
4377   Dali::Vector3 *result = 0 ;
4378
4379   result = (Dali::Vector3 *)&Dali::Vector3::ZAXIS;
4380   jresult = (void *)result;
4381   return jresult;
4382 }
4383
4384
4385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_XAXIS_get() {
4386   void * jresult ;
4387   Dali::Vector3 *result = 0 ;
4388
4389   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_XAXIS;
4390   jresult = (void *)result;
4391   return jresult;
4392 }
4393
4394
4395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_YAXIS_get() {
4396   void * jresult ;
4397   Dali::Vector3 *result = 0 ;
4398
4399   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_YAXIS;
4400   jresult = (void *)result;
4401   return jresult;
4402 }
4403
4404
4405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_ZAXIS_get() {
4406   void * jresult ;
4407   Dali::Vector3 *result = 0 ;
4408
4409   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_ZAXIS;
4410   jresult = (void *)result;
4411   return jresult;
4412 }
4413
4414
4415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZERO_get() {
4416   void * jresult ;
4417   Dali::Vector3 *result = 0 ;
4418
4419   result = (Dali::Vector3 *)&Dali::Vector3::ZERO;
4420   jresult = (void *)result;
4421   return jresult;
4422 }
4423
4424
4425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_0(void * jarg1, float* jarg2) {
4426   void * jresult ;
4427   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4428   float *arg2 = (float *) 0 ;
4429   Dali::Vector3 *result = 0 ;
4430
4431   arg1 = (Dali::Vector3 *)jarg1;
4432   arg2 = jarg2;
4433   {
4434     try {
4435       result = (Dali::Vector3 *) &(arg1)->operator =((float const *)arg2);
4436     } CALL_CATCH_EXCEPTION(0);
4437   }
4438
4439   jresult = (void *)result;
4440
4441
4442   return jresult;
4443 }
4444
4445
4446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_1(void * jarg1, void * jarg2) {
4447   void * jresult ;
4448   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4449   Dali::Vector2 *arg2 = 0 ;
4450   Dali::Vector3 *result = 0 ;
4451
4452   arg1 = (Dali::Vector3 *)jarg1;
4453   arg2 = (Dali::Vector2 *)jarg2;
4454   if (!arg2) {
4455     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4456     return 0;
4457   }
4458   {
4459     try {
4460       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
4461     } CALL_CATCH_EXCEPTION(0);
4462   }
4463
4464   jresult = (void *)result;
4465   return jresult;
4466 }
4467
4468
4469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_2(void * jarg1, void * jarg2) {
4470   void * jresult ;
4471   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4472   Dali::Vector4 *arg2 = 0 ;
4473   Dali::Vector3 *result = 0 ;
4474
4475   arg1 = (Dali::Vector3 *)jarg1;
4476   arg2 = (Dali::Vector4 *)jarg2;
4477   if (!arg2) {
4478     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4479     return 0;
4480   }
4481   {
4482     try {
4483       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
4484     } CALL_CATCH_EXCEPTION(0);
4485   }
4486
4487   jresult = (void *)result;
4488   return jresult;
4489 }
4490
4491
4492 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Add(void * jarg1, void * jarg2) {
4493   void * jresult ;
4494   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4495   Dali::Vector3 *arg2 = 0 ;
4496   Dali::Vector3 result;
4497
4498   arg1 = (Dali::Vector3 *)jarg1;
4499   arg2 = (Dali::Vector3 *)jarg2;
4500   if (!arg2) {
4501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4502     return 0;
4503   }
4504   {
4505     try {
4506       result = ((Dali::Vector3 const *)arg1)->operator +((Dali::Vector3 const &)*arg2);
4507     } CALL_CATCH_EXCEPTION(0);
4508   }
4509
4510   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
4511   return jresult;
4512 }
4513
4514
4515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AddAssign(void * jarg1, void * jarg2) {
4516   void * jresult ;
4517   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4518   Dali::Vector3 *arg2 = 0 ;
4519   Dali::Vector3 *result = 0 ;
4520
4521   arg1 = (Dali::Vector3 *)jarg1;
4522   arg2 = (Dali::Vector3 *)jarg2;
4523   if (!arg2) {
4524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4525     return 0;
4526   }
4527   {
4528     try {
4529       result = (Dali::Vector3 *) &(arg1)->operator +=((Dali::Vector3 const &)*arg2);
4530     } CALL_CATCH_EXCEPTION(0);
4531   }
4532
4533   jresult = (void *)result;
4534   return jresult;
4535 }
4536
4537
4538 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_0(void * jarg1, void * jarg2) {
4539   void * jresult ;
4540   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4541   Dali::Vector3 *arg2 = 0 ;
4542   Dali::Vector3 result;
4543
4544   arg1 = (Dali::Vector3 *)jarg1;
4545   arg2 = (Dali::Vector3 *)jarg2;
4546   if (!arg2) {
4547     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4548     return 0;
4549   }
4550   {
4551     try {
4552       result = ((Dali::Vector3 const *)arg1)->operator -((Dali::Vector3 const &)*arg2);
4553     } CALL_CATCH_EXCEPTION(0);
4554   }
4555
4556   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
4557   return jresult;
4558 }
4559
4560
4561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_SubtractAssign(void * jarg1, void * jarg2) {
4562   void * jresult ;
4563   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4564   Dali::Vector3 *arg2 = 0 ;
4565   Dali::Vector3 *result = 0 ;
4566
4567   arg1 = (Dali::Vector3 *)jarg1;
4568   arg2 = (Dali::Vector3 *)jarg2;
4569   if (!arg2) {
4570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4571     return 0;
4572   }
4573   {
4574     try {
4575       result = (Dali::Vector3 *) &(arg1)->operator -=((Dali::Vector3 const &)*arg2);
4576     } CALL_CATCH_EXCEPTION(0);
4577   }
4578
4579   jresult = (void *)result;
4580   return jresult;
4581 }
4582
4583
4584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_0(void * jarg1, void * jarg2) {
4585   void * jresult ;
4586   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4587   Dali::Vector3 *arg2 = 0 ;
4588   Dali::Vector3 result;
4589
4590   arg1 = (Dali::Vector3 *)jarg1;
4591   arg2 = (Dali::Vector3 *)jarg2;
4592   if (!arg2) {
4593     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4594     return 0;
4595   }
4596   {
4597     try {
4598       result = ((Dali::Vector3 const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
4599     } CALL_CATCH_EXCEPTION(0);
4600   }
4601
4602   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
4603   return jresult;
4604 }
4605
4606
4607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_1(void * jarg1, float jarg2) {
4608   void * jresult ;
4609   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4610   float arg2 ;
4611   Dali::Vector3 result;
4612
4613   arg1 = (Dali::Vector3 *)jarg1;
4614   arg2 = (float)jarg2;
4615   {
4616     try {
4617       result = ((Dali::Vector3 const *)arg1)->operator *(arg2);
4618     } CALL_CATCH_EXCEPTION(0);
4619   }
4620
4621   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
4622   return jresult;
4623 }
4624
4625
4626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
4627   void * jresult ;
4628   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4629   Dali::Vector3 *arg2 = 0 ;
4630   Dali::Vector3 *result = 0 ;
4631
4632   arg1 = (Dali::Vector3 *)jarg1;
4633   arg2 = (Dali::Vector3 *)jarg2;
4634   if (!arg2) {
4635     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4636     return 0;
4637   }
4638   {
4639     try {
4640       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Vector3 const &)*arg2);
4641     } CALL_CATCH_EXCEPTION(0);
4642   }
4643
4644   jresult = (void *)result;
4645   return jresult;
4646 }
4647
4648
4649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
4650   void * jresult ;
4651   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4652   float arg2 ;
4653   Dali::Vector3 *result = 0 ;
4654
4655   arg1 = (Dali::Vector3 *)jarg1;
4656   arg2 = (float)jarg2;
4657   {
4658     try {
4659       result = (Dali::Vector3 *) &(arg1)->operator *=(arg2);
4660     } CALL_CATCH_EXCEPTION(0);
4661   }
4662
4663   jresult = (void *)result;
4664   return jresult;
4665 }
4666
4667
4668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_2(void * jarg1, void * jarg2) {
4669   void * jresult ;
4670   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4671   Dali::Quaternion *arg2 = 0 ;
4672   Dali::Vector3 *result = 0 ;
4673
4674   arg1 = (Dali::Vector3 *)jarg1;
4675   arg2 = (Dali::Quaternion *)jarg2;
4676   if (!arg2) {
4677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
4678     return 0;
4679   }
4680   {
4681     try {
4682       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
4683     } CALL_CATCH_EXCEPTION(0);
4684   }
4685
4686   jresult = (void *)result;
4687   return jresult;
4688 }
4689
4690
4691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_0(void * jarg1, void * jarg2) {
4692   void * jresult ;
4693   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4694   Dali::Vector3 *arg2 = 0 ;
4695   Dali::Vector3 result;
4696
4697   arg1 = (Dali::Vector3 *)jarg1;
4698   arg2 = (Dali::Vector3 *)jarg2;
4699   if (!arg2) {
4700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4701     return 0;
4702   }
4703   {
4704     try {
4705       result = ((Dali::Vector3 const *)arg1)->operator /((Dali::Vector3 const &)*arg2);
4706     } CALL_CATCH_EXCEPTION(0);
4707   }
4708
4709   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
4710   return jresult;
4711 }
4712
4713
4714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_1(void * jarg1, float jarg2) {
4715   void * jresult ;
4716   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4717   float arg2 ;
4718   Dali::Vector3 result;
4719
4720   arg1 = (Dali::Vector3 *)jarg1;
4721   arg2 = (float)jarg2;
4722   {
4723     try {
4724       result = ((Dali::Vector3 const *)arg1)->operator /(arg2);
4725     } CALL_CATCH_EXCEPTION(0);
4726   }
4727
4728   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
4729   return jresult;
4730 }
4731
4732
4733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
4734   void * jresult ;
4735   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4736   Dali::Vector3 *arg2 = 0 ;
4737   Dali::Vector3 *result = 0 ;
4738
4739   arg1 = (Dali::Vector3 *)jarg1;
4740   arg2 = (Dali::Vector3 *)jarg2;
4741   if (!arg2) {
4742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4743     return 0;
4744   }
4745   {
4746     try {
4747       result = (Dali::Vector3 *) &(arg1)->operator /=((Dali::Vector3 const &)*arg2);
4748     } CALL_CATCH_EXCEPTION(0);
4749   }
4750
4751   jresult = (void *)result;
4752   return jresult;
4753 }
4754
4755
4756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
4757   void * jresult ;
4758   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4759   float arg2 ;
4760   Dali::Vector3 *result = 0 ;
4761
4762   arg1 = (Dali::Vector3 *)jarg1;
4763   arg2 = (float)jarg2;
4764   {
4765     try {
4766       result = (Dali::Vector3 *) &(arg1)->operator /=(arg2);
4767     } CALL_CATCH_EXCEPTION(0);
4768   }
4769
4770   jresult = (void *)result;
4771   return jresult;
4772 }
4773
4774
4775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_1(void * jarg1) {
4776   void * jresult ;
4777   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4778   Dali::Vector3 result;
4779
4780   arg1 = (Dali::Vector3 *)jarg1;
4781   {
4782     try {
4783       result = ((Dali::Vector3 const *)arg1)->operator -();
4784     } CALL_CATCH_EXCEPTION(0);
4785   }
4786
4787   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
4788   return jresult;
4789 }
4790
4791
4792 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_EqualTo(void * jarg1, void * jarg2) {
4793   unsigned int jresult ;
4794   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4795   Dali::Vector3 *arg2 = 0 ;
4796   bool result;
4797
4798   arg1 = (Dali::Vector3 *)jarg1;
4799   arg2 = (Dali::Vector3 *)jarg2;
4800   if (!arg2) {
4801     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4802     return 0;
4803   }
4804   {
4805     try {
4806       result = (bool)((Dali::Vector3 const *)arg1)->operator ==((Dali::Vector3 const &)*arg2);
4807     } CALL_CATCH_EXCEPTION(0);
4808   }
4809
4810   jresult = result;
4811   return jresult;
4812 }
4813
4814
4815 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_NotEqualTo(void * jarg1, void * jarg2) {
4816   unsigned int jresult ;
4817   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4818   Dali::Vector3 *arg2 = 0 ;
4819   bool result;
4820
4821   arg1 = (Dali::Vector3 *)jarg1;
4822   arg2 = (Dali::Vector3 *)jarg2;
4823   if (!arg2) {
4824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4825     return 0;
4826   }
4827   {
4828     try {
4829       result = (bool)((Dali::Vector3 const *)arg1)->operator !=((Dali::Vector3 const &)*arg2);
4830     } CALL_CATCH_EXCEPTION(0);
4831   }
4832
4833   jresult = result;
4834   return jresult;
4835 }
4836
4837
4838 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
4839   float jresult ;
4840   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4841   unsigned int arg2 ;
4842   float *result = 0 ;
4843
4844   arg1 = (Dali::Vector3 *)jarg1;
4845   arg2 = (unsigned int)jarg2;
4846   {
4847     try {
4848       result = (float *) &((Dali::Vector3 const *)arg1)->operator [](arg2);
4849     } CALL_CATCH_EXCEPTION(0);
4850   }
4851
4852   jresult = *result;
4853   return jresult;
4854 }
4855
4856
4857 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Dot(void * jarg1, void * jarg2) {
4858   float jresult ;
4859   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4860   Dali::Vector3 *arg2 = 0 ;
4861   float result;
4862
4863   arg1 = (Dali::Vector3 *)jarg1;
4864   arg2 = (Dali::Vector3 *)jarg2;
4865   if (!arg2) {
4866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4867     return 0;
4868   }
4869   {
4870     try {
4871       result = (float)((Dali::Vector3 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
4872     } CALL_CATCH_EXCEPTION(0);
4873   }
4874
4875   jresult = result;
4876   return jresult;
4877 }
4878
4879
4880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Cross(void * jarg1, void * jarg2) {
4881   void * jresult ;
4882   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4883   Dali::Vector3 *arg2 = 0 ;
4884   Dali::Vector3 result;
4885
4886   arg1 = (Dali::Vector3 *)jarg1;
4887   arg2 = (Dali::Vector3 *)jarg2;
4888   if (!arg2) {
4889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4890     return 0;
4891   }
4892   {
4893     try {
4894       result = ((Dali::Vector3 const *)arg1)->Cross((Dali::Vector3 const &)*arg2);
4895     } CALL_CATCH_EXCEPTION(0);
4896   }
4897
4898   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
4899   return jresult;
4900 }
4901
4902
4903 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Length(void * jarg1) {
4904   float jresult ;
4905   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4906   float result;
4907
4908   arg1 = (Dali::Vector3 *)jarg1;
4909   {
4910     try {
4911       result = (float)((Dali::Vector3 const *)arg1)->Length();
4912     } CALL_CATCH_EXCEPTION(0);
4913   }
4914
4915   jresult = result;
4916   return jresult;
4917 }
4918
4919
4920 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_LengthSquared(void * jarg1) {
4921   float jresult ;
4922   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4923   float result;
4924
4925   arg1 = (Dali::Vector3 *)jarg1;
4926   {
4927     try {
4928       result = (float)((Dali::Vector3 const *)arg1)->LengthSquared();
4929     } CALL_CATCH_EXCEPTION(0);
4930   }
4931
4932   jresult = result;
4933   return jresult;
4934 }
4935
4936
4937 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Normalize(void * jarg1) {
4938   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4939
4940   arg1 = (Dali::Vector3 *)jarg1;
4941   {
4942     try {
4943       (arg1)->Normalize();
4944     } CALL_CATCH_EXCEPTION();
4945   }
4946
4947 }
4948
4949
4950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Clamp(void * jarg1, void * jarg2, void * jarg3) {
4951   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4952   Dali::Vector3 *arg2 = 0 ;
4953   Dali::Vector3 *arg3 = 0 ;
4954
4955   arg1 = (Dali::Vector3 *)jarg1;
4956   arg2 = (Dali::Vector3 *)jarg2;
4957   if (!arg2) {
4958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4959     return ;
4960   }
4961   arg3 = (Dali::Vector3 *)jarg3;
4962   if (!arg3) {
4963     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4964     return ;
4965   }
4966   {
4967     try {
4968       (arg1)->Clamp((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3);
4969     } CALL_CATCH_EXCEPTION();
4970   }
4971
4972 }
4973
4974
4975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AsFloat__SWIG_0(void * jarg1) {
4976   void * jresult ;
4977   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4978   float *result = 0 ;
4979
4980   arg1 = (Dali::Vector3 *)jarg1;
4981   {
4982     try {
4983       result = (float *)((Dali::Vector3 const *)arg1)->AsFloat();
4984     } CALL_CATCH_EXCEPTION(0);
4985   }
4986
4987   jresult = (void *)result;
4988   return jresult;
4989 }
4990
4991
4992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorXY__SWIG_0(void * jarg1) {
4993   void * jresult ;
4994   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4995   Dali::Vector2 *result = 0 ;
4996
4997   arg1 = (Dali::Vector3 *)jarg1;
4998   {
4999     try {
5000       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorXY();
5001     } CALL_CATCH_EXCEPTION(0);
5002   }
5003
5004   jresult = (void *)result;
5005   return jresult;
5006 }
5007
5008
5009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorYZ__SWIG_0(void * jarg1) {
5010   void * jresult ;
5011   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5012   Dali::Vector2 *result = 0 ;
5013
5014   arg1 = (Dali::Vector3 *)jarg1;
5015   {
5016     try {
5017       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorYZ();
5018     } CALL_CATCH_EXCEPTION(0);
5019   }
5020
5021   jresult = (void *)result;
5022   return jresult;
5023 }
5024
5025
5026 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_X_set(void * jarg1, float jarg2) {
5027   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5028   float arg2 ;
5029
5030   arg1 = (Dali::Vector3 *)jarg1;
5031   arg2 = (float)jarg2;
5032   if (arg1) (arg1)->x = arg2;
5033 }
5034
5035
5036 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_X_get(void * jarg1) {
5037   float jresult ;
5038   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5039   float result;
5040
5041   arg1 = (Dali::Vector3 *)jarg1;
5042   result = (float) ((arg1)->x);
5043   jresult = result;
5044   return jresult;
5045 }
5046
5047
5048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Width_set(void * jarg1, float jarg2) {
5049   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5050   float arg2 ;
5051
5052   arg1 = (Dali::Vector3 *)jarg1;
5053   arg2 = (float)jarg2;
5054   if (arg1) (arg1)->width = arg2;
5055 }
5056
5057
5058 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Width_get(void * jarg1) {
5059   float jresult ;
5060   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5061   float result;
5062
5063   arg1 = (Dali::Vector3 *)jarg1;
5064   result = (float) ((arg1)->width);
5065   jresult = result;
5066   return jresult;
5067 }
5068
5069
5070 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_r_set(void * jarg1, float jarg2) {
5071   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5072   float arg2 ;
5073
5074   arg1 = (Dali::Vector3 *)jarg1;
5075   arg2 = (float)jarg2;
5076   if (arg1) (arg1)->r = arg2;
5077 }
5078
5079
5080 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_r_get(void * jarg1) {
5081   float jresult ;
5082   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5083   float result;
5084
5085   arg1 = (Dali::Vector3 *)jarg1;
5086   result = (float) ((arg1)->r);
5087   jresult = result;
5088   return jresult;
5089 }
5090
5091
5092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Y_set(void * jarg1, float jarg2) {
5093   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5094   float arg2 ;
5095
5096   arg1 = (Dali::Vector3 *)jarg1;
5097   arg2 = (float)jarg2;
5098   if (arg1) (arg1)->y = arg2;
5099 }
5100
5101
5102 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Y_get(void * jarg1) {
5103   float jresult ;
5104   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5105   float result;
5106
5107   arg1 = (Dali::Vector3 *)jarg1;
5108   result = (float) ((arg1)->y);
5109   jresult = result;
5110   return jresult;
5111 }
5112
5113
5114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Height_set(void * jarg1, float jarg2) {
5115   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5116   float arg2 ;
5117
5118   arg1 = (Dali::Vector3 *)jarg1;
5119   arg2 = (float)jarg2;
5120   if (arg1) (arg1)->height = arg2;
5121 }
5122
5123
5124 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Height_get(void * jarg1) {
5125   float jresult ;
5126   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5127   float result;
5128
5129   arg1 = (Dali::Vector3 *)jarg1;
5130   result = (float) ((arg1)->height);
5131   jresult = result;
5132   return jresult;
5133 }
5134
5135
5136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_g_set(void * jarg1, float jarg2) {
5137   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5138   float arg2 ;
5139
5140   arg1 = (Dali::Vector3 *)jarg1;
5141   arg2 = (float)jarg2;
5142   if (arg1) (arg1)->g = arg2;
5143 }
5144
5145
5146 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_g_get(void * jarg1) {
5147   float jresult ;
5148   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5149   float result;
5150
5151   arg1 = (Dali::Vector3 *)jarg1;
5152   result = (float) ((arg1)->g);
5153   jresult = result;
5154   return jresult;
5155 }
5156
5157
5158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Z_set(void * jarg1, float jarg2) {
5159   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5160   float arg2 ;
5161
5162   arg1 = (Dali::Vector3 *)jarg1;
5163   arg2 = (float)jarg2;
5164   if (arg1) (arg1)->z = arg2;
5165 }
5166
5167
5168 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Z_get(void * jarg1) {
5169   float jresult ;
5170   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5171   float result;
5172
5173   arg1 = (Dali::Vector3 *)jarg1;
5174   result = (float) ((arg1)->z);
5175   jresult = result;
5176   return jresult;
5177 }
5178
5179
5180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Depth_set(void * jarg1, float jarg2) {
5181   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5182   float arg2 ;
5183
5184   arg1 = (Dali::Vector3 *)jarg1;
5185   arg2 = (float)jarg2;
5186   if (arg1) (arg1)->depth = arg2;
5187 }
5188
5189
5190 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Depth_get(void * jarg1) {
5191   float jresult ;
5192   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5193   float result;
5194
5195   arg1 = (Dali::Vector3 *)jarg1;
5196   result = (float) ((arg1)->depth);
5197   jresult = result;
5198   return jresult;
5199 }
5200
5201
5202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_b_set(void * jarg1, float jarg2) {
5203   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5204   float arg2 ;
5205
5206   arg1 = (Dali::Vector3 *)jarg1;
5207   arg2 = (float)jarg2;
5208   if (arg1) (arg1)->b = arg2;
5209 }
5210
5211
5212 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_b_get(void * jarg1) {
5213   float jresult ;
5214   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5215   float result;
5216
5217   arg1 = (Dali::Vector3 *)jarg1;
5218   result = (float) ((arg1)->b);
5219   jresult = result;
5220   return jresult;
5221 }
5222
5223
5224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector3(void * jarg1) {
5225   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5226
5227   arg1 = (Dali::Vector3 *)jarg1;
5228   {
5229     try {
5230       delete arg1;
5231     } CALL_CATCH_EXCEPTION();
5232   }
5233
5234 }
5235
5236
5237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_1(void * jarg1, void * jarg2) {
5238   void * jresult ;
5239   Dali::Vector3 *arg1 = 0 ;
5240   Dali::Vector3 *arg2 = 0 ;
5241   Dali::Vector3 result;
5242
5243   arg1 = (Dali::Vector3 *)jarg1;
5244   if (!arg1) {
5245     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5246     return 0;
5247   }
5248   arg2 = (Dali::Vector3 *)jarg2;
5249   if (!arg2) {
5250     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5251     return 0;
5252   }
5253   {
5254     try {
5255       result = Dali::Min((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
5256     } CALL_CATCH_EXCEPTION(0);
5257   }
5258
5259   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5260   return jresult;
5261 }
5262
5263
5264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_1(void * jarg1, void * jarg2) {
5265   void * jresult ;
5266   Dali::Vector3 *arg1 = 0 ;
5267   Dali::Vector3 *arg2 = 0 ;
5268   Dali::Vector3 result;
5269
5270   arg1 = (Dali::Vector3 *)jarg1;
5271   if (!arg1) {
5272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5273     return 0;
5274   }
5275   arg2 = (Dali::Vector3 *)jarg2;
5276   if (!arg2) {
5277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5278     return 0;
5279   }
5280   {
5281     try {
5282       result = Dali::Max((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
5283     } CALL_CATCH_EXCEPTION(0);
5284   }
5285
5286   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5287   return jresult;
5288 }
5289
5290
5291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
5292   void * jresult ;
5293   Dali::Vector3 *arg1 = 0 ;
5294   float *arg2 = 0 ;
5295   float *arg3 = 0 ;
5296   float temp2 ;
5297   float temp3 ;
5298   Dali::Vector3 result;
5299
5300   arg1 = (Dali::Vector3 *)jarg1;
5301   if (!arg1) {
5302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5303     return 0;
5304   }
5305   temp2 = (float)jarg2;
5306   arg2 = &temp2;
5307   temp3 = (float)jarg3;
5308   arg3 = &temp3;
5309   {
5310     try {
5311       result = Dali::Clamp((Dali::Vector3 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
5312     } CALL_CATCH_EXCEPTION(0);
5313   }
5314
5315   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5316   return jresult;
5317 }
5318
5319
5320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_0() {
5321   void * jresult ;
5322   Dali::Vector4 *result = 0 ;
5323
5324   {
5325     try {
5326       result = (Dali::Vector4 *)new Dali::Vector4();
5327     } CALL_CATCH_EXCEPTION(0);
5328   }
5329
5330   jresult = (void *)result;
5331   return jresult;
5332 }
5333
5334
5335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
5336   void * jresult ;
5337   float arg1 ;
5338   float arg2 ;
5339   float arg3 ;
5340   float arg4 ;
5341   Dali::Vector4 *result = 0 ;
5342
5343   arg1 = (float)jarg1;
5344   arg2 = (float)jarg2;
5345   arg3 = (float)jarg3;
5346   arg4 = (float)jarg4;
5347   {
5348     try {
5349       result = (Dali::Vector4 *)new Dali::Vector4(arg1,arg2,arg3,arg4);
5350     } CALL_CATCH_EXCEPTION(0);
5351   }
5352
5353   jresult = (void *)result;
5354   return jresult;
5355 }
5356
5357
5358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_2(float* jarg1) {
5359   void * jresult ;
5360   float *arg1 = (float *) 0 ;
5361   Dali::Vector4 *result = 0 ;
5362
5363   arg1 = jarg1;
5364   {
5365     try {
5366       result = (Dali::Vector4 *)new Dali::Vector4((float const *)arg1);
5367     } CALL_CATCH_EXCEPTION(0);
5368   }
5369
5370   jresult = (void *)result;
5371
5372
5373   return jresult;
5374 }
5375
5376
5377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_3(void * jarg1) {
5378   void * jresult ;
5379   Dali::Vector2 *arg1 = 0 ;
5380   Dali::Vector4 *result = 0 ;
5381
5382   arg1 = (Dali::Vector2 *)jarg1;
5383   if (!arg1) {
5384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5385     return 0;
5386   }
5387   {
5388     try {
5389       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector2 const &)*arg1);
5390     } CALL_CATCH_EXCEPTION(0);
5391   }
5392
5393   jresult = (void *)result;
5394   return jresult;
5395 }
5396
5397
5398 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_4(void * jarg1) {
5399   void * jresult ;
5400   Dali::Vector3 *arg1 = 0 ;
5401   Dali::Vector4 *result = 0 ;
5402
5403   arg1 = (Dali::Vector3 *)jarg1;
5404   if (!arg1) {
5405     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5406     return 0;
5407   }
5408   {
5409     try {
5410       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector3 const &)*arg1);
5411     } CALL_CATCH_EXCEPTION(0);
5412   }
5413
5414   jresult = (void *)result;
5415   return jresult;
5416 }
5417
5418
5419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ONE_get() {
5420   void * jresult ;
5421   Dali::Vector4 *result = 0 ;
5422
5423   result = (Dali::Vector4 *)&Dali::Vector4::ONE;
5424   jresult = (void *)result;
5425   return jresult;
5426 }
5427
5428
5429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_XAXIS_get() {
5430   void * jresult ;
5431   Dali::Vector4 *result = 0 ;
5432
5433   result = (Dali::Vector4 *)&Dali::Vector4::XAXIS;
5434   jresult = (void *)result;
5435   return jresult;
5436 }
5437
5438
5439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_YAXIS_get() {
5440   void * jresult ;
5441   Dali::Vector4 *result = 0 ;
5442
5443   result = (Dali::Vector4 *)&Dali::Vector4::YAXIS;
5444   jresult = (void *)result;
5445   return jresult;
5446 }
5447
5448
5449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZAXIS_get() {
5450   void * jresult ;
5451   Dali::Vector4 *result = 0 ;
5452
5453   result = (Dali::Vector4 *)&Dali::Vector4::ZAXIS;
5454   jresult = (void *)result;
5455   return jresult;
5456 }
5457
5458
5459 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZERO_get() {
5460   void * jresult ;
5461   Dali::Vector4 *result = 0 ;
5462
5463   result = (Dali::Vector4 *)&Dali::Vector4::ZERO;
5464   jresult = (void *)result;
5465   return jresult;
5466 }
5467
5468
5469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_0(void * jarg1, float* jarg2) {
5470   void * jresult ;
5471   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5472   float *arg2 = (float *) 0 ;
5473   Dali::Vector4 *result = 0 ;
5474
5475   arg1 = (Dali::Vector4 *)jarg1;
5476   arg2 = jarg2;
5477   {
5478     try {
5479       result = (Dali::Vector4 *) &(arg1)->operator =((float const *)arg2);
5480     } CALL_CATCH_EXCEPTION(0);
5481   }
5482
5483   jresult = (void *)result;
5484
5485
5486   return jresult;
5487 }
5488
5489
5490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_1(void * jarg1, void * jarg2) {
5491   void * jresult ;
5492   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5493   Dali::Vector2 *arg2 = 0 ;
5494   Dali::Vector4 *result = 0 ;
5495
5496   arg1 = (Dali::Vector4 *)jarg1;
5497   arg2 = (Dali::Vector2 *)jarg2;
5498   if (!arg2) {
5499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5500     return 0;
5501   }
5502   {
5503     try {
5504       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
5505     } CALL_CATCH_EXCEPTION(0);
5506   }
5507
5508   jresult = (void *)result;
5509   return jresult;
5510 }
5511
5512
5513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_2(void * jarg1, void * jarg2) {
5514   void * jresult ;
5515   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5516   Dali::Vector3 *arg2 = 0 ;
5517   Dali::Vector4 *result = 0 ;
5518
5519   arg1 = (Dali::Vector4 *)jarg1;
5520   arg2 = (Dali::Vector3 *)jarg2;
5521   if (!arg2) {
5522     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5523     return 0;
5524   }
5525   {
5526     try {
5527       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
5528     } CALL_CATCH_EXCEPTION(0);
5529   }
5530
5531   jresult = (void *)result;
5532   return jresult;
5533 }
5534
5535
5536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Add(void * jarg1, void * jarg2) {
5537   void * jresult ;
5538   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5539   Dali::Vector4 *arg2 = 0 ;
5540   Dali::Vector4 result;
5541
5542   arg1 = (Dali::Vector4 *)jarg1;
5543   arg2 = (Dali::Vector4 *)jarg2;
5544   if (!arg2) {
5545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5546     return 0;
5547   }
5548   {
5549     try {
5550       result = ((Dali::Vector4 const *)arg1)->operator +((Dali::Vector4 const &)*arg2);
5551     } CALL_CATCH_EXCEPTION(0);
5552   }
5553
5554   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
5555   return jresult;
5556 }
5557
5558
5559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AddAssign(void * jarg1, void * jarg2) {
5560   void * jresult ;
5561   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5562   Dali::Vector4 *arg2 = 0 ;
5563   Dali::Vector4 *result = 0 ;
5564
5565   arg1 = (Dali::Vector4 *)jarg1;
5566   arg2 = (Dali::Vector4 *)jarg2;
5567   if (!arg2) {
5568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5569     return 0;
5570   }
5571   {
5572     try {
5573       result = (Dali::Vector4 *) &(arg1)->operator +=((Dali::Vector4 const &)*arg2);
5574     } CALL_CATCH_EXCEPTION(0);
5575   }
5576
5577   jresult = (void *)result;
5578   return jresult;
5579 }
5580
5581
5582 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_0(void * jarg1, void * jarg2) {
5583   void * jresult ;
5584   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5585   Dali::Vector4 *arg2 = 0 ;
5586   Dali::Vector4 result;
5587
5588   arg1 = (Dali::Vector4 *)jarg1;
5589   arg2 = (Dali::Vector4 *)jarg2;
5590   if (!arg2) {
5591     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5592     return 0;
5593   }
5594   {
5595     try {
5596       result = ((Dali::Vector4 const *)arg1)->operator -((Dali::Vector4 const &)*arg2);
5597     } CALL_CATCH_EXCEPTION(0);
5598   }
5599
5600   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
5601   return jresult;
5602 }
5603
5604
5605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_SubtractAssign(void * jarg1, void * jarg2) {
5606   void * jresult ;
5607   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5608   Dali::Vector4 *arg2 = 0 ;
5609   Dali::Vector4 *result = 0 ;
5610
5611   arg1 = (Dali::Vector4 *)jarg1;
5612   arg2 = (Dali::Vector4 *)jarg2;
5613   if (!arg2) {
5614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5615     return 0;
5616   }
5617   {
5618     try {
5619       result = (Dali::Vector4 *) &(arg1)->operator -=((Dali::Vector4 const &)*arg2);
5620     } CALL_CATCH_EXCEPTION(0);
5621   }
5622
5623   jresult = (void *)result;
5624   return jresult;
5625 }
5626
5627
5628 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_0(void * jarg1, void * jarg2) {
5629   void * jresult ;
5630   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5631   Dali::Vector4 *arg2 = 0 ;
5632   Dali::Vector4 result;
5633
5634   arg1 = (Dali::Vector4 *)jarg1;
5635   arg2 = (Dali::Vector4 *)jarg2;
5636   if (!arg2) {
5637     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5638     return 0;
5639   }
5640   {
5641     try {
5642       result = ((Dali::Vector4 const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
5643     } CALL_CATCH_EXCEPTION(0);
5644   }
5645
5646   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
5647   return jresult;
5648 }
5649
5650
5651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_1(void * jarg1, float jarg2) {
5652   void * jresult ;
5653   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5654   float arg2 ;
5655   Dali::Vector4 result;
5656
5657   arg1 = (Dali::Vector4 *)jarg1;
5658   arg2 = (float)jarg2;
5659   {
5660     try {
5661       result = ((Dali::Vector4 const *)arg1)->operator *(arg2);
5662     } CALL_CATCH_EXCEPTION(0);
5663   }
5664
5665   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
5666   return jresult;
5667 }
5668
5669
5670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
5671   void * jresult ;
5672   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5673   Dali::Vector4 *arg2 = 0 ;
5674   Dali::Vector4 *result = 0 ;
5675
5676   arg1 = (Dali::Vector4 *)jarg1;
5677   arg2 = (Dali::Vector4 *)jarg2;
5678   if (!arg2) {
5679     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5680     return 0;
5681   }
5682   {
5683     try {
5684       result = (Dali::Vector4 *) &(arg1)->operator *=((Dali::Vector4 const &)*arg2);
5685     } CALL_CATCH_EXCEPTION(0);
5686   }
5687
5688   jresult = (void *)result;
5689   return jresult;
5690 }
5691
5692
5693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
5694   void * jresult ;
5695   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5696   float arg2 ;
5697   Dali::Vector4 *result = 0 ;
5698
5699   arg1 = (Dali::Vector4 *)jarg1;
5700   arg2 = (float)jarg2;
5701   {
5702     try {
5703       result = (Dali::Vector4 *) &(arg1)->operator *=(arg2);
5704     } CALL_CATCH_EXCEPTION(0);
5705   }
5706
5707   jresult = (void *)result;
5708   return jresult;
5709 }
5710
5711
5712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_0(void * jarg1, void * jarg2) {
5713   void * jresult ;
5714   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5715   Dali::Vector4 *arg2 = 0 ;
5716   Dali::Vector4 result;
5717
5718   arg1 = (Dali::Vector4 *)jarg1;
5719   arg2 = (Dali::Vector4 *)jarg2;
5720   if (!arg2) {
5721     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5722     return 0;
5723   }
5724   {
5725     try {
5726       result = ((Dali::Vector4 const *)arg1)->operator /((Dali::Vector4 const &)*arg2);
5727     } CALL_CATCH_EXCEPTION(0);
5728   }
5729
5730   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
5731   return jresult;
5732 }
5733
5734
5735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_1(void * jarg1, float jarg2) {
5736   void * jresult ;
5737   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5738   float arg2 ;
5739   Dali::Vector4 result;
5740
5741   arg1 = (Dali::Vector4 *)jarg1;
5742   arg2 = (float)jarg2;
5743   {
5744     try {
5745       result = ((Dali::Vector4 const *)arg1)->operator /(arg2);
5746     } CALL_CATCH_EXCEPTION(0);
5747   }
5748
5749   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
5750   return jresult;
5751 }
5752
5753
5754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
5755   void * jresult ;
5756   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5757   Dali::Vector4 *arg2 = 0 ;
5758   Dali::Vector4 *result = 0 ;
5759
5760   arg1 = (Dali::Vector4 *)jarg1;
5761   arg2 = (Dali::Vector4 *)jarg2;
5762   if (!arg2) {
5763     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5764     return 0;
5765   }
5766   {
5767     try {
5768       result = (Dali::Vector4 *) &(arg1)->operator /=((Dali::Vector4 const &)*arg2);
5769     } CALL_CATCH_EXCEPTION(0);
5770   }
5771
5772   jresult = (void *)result;
5773   return jresult;
5774 }
5775
5776
5777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
5778   void * jresult ;
5779   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5780   float arg2 ;
5781   Dali::Vector4 *result = 0 ;
5782
5783   arg1 = (Dali::Vector4 *)jarg1;
5784   arg2 = (float)jarg2;
5785   {
5786     try {
5787       result = (Dali::Vector4 *) &(arg1)->operator /=(arg2);
5788     } CALL_CATCH_EXCEPTION(0);
5789   }
5790
5791   jresult = (void *)result;
5792   return jresult;
5793 }
5794
5795
5796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_1(void * jarg1) {
5797   void * jresult ;
5798   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5799   Dali::Vector4 result;
5800
5801   arg1 = (Dali::Vector4 *)jarg1;
5802   {
5803     try {
5804       result = ((Dali::Vector4 const *)arg1)->operator -();
5805     } CALL_CATCH_EXCEPTION(0);
5806   }
5807
5808   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
5809   return jresult;
5810 }
5811
5812
5813 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_EqualTo(void * jarg1, void * jarg2) {
5814   unsigned int jresult ;
5815   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5816   Dali::Vector4 *arg2 = 0 ;
5817   bool result;
5818
5819   arg1 = (Dali::Vector4 *)jarg1;
5820   arg2 = (Dali::Vector4 *)jarg2;
5821   if (!arg2) {
5822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5823     return 0;
5824   }
5825   {
5826     try {
5827       result = (bool)((Dali::Vector4 const *)arg1)->operator ==((Dali::Vector4 const &)*arg2);
5828     } CALL_CATCH_EXCEPTION(0);
5829   }
5830
5831   jresult = result;
5832   return jresult;
5833 }
5834
5835
5836 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_NotEqualTo(void * jarg1, void * jarg2) {
5837   unsigned int jresult ;
5838   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5839   Dali::Vector4 *arg2 = 0 ;
5840   bool result;
5841
5842   arg1 = (Dali::Vector4 *)jarg1;
5843   arg2 = (Dali::Vector4 *)jarg2;
5844   if (!arg2) {
5845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5846     return 0;
5847   }
5848   {
5849     try {
5850       result = (bool)((Dali::Vector4 const *)arg1)->operator !=((Dali::Vector4 const &)*arg2);
5851     } CALL_CATCH_EXCEPTION(0);
5852   }
5853
5854   jresult = result;
5855   return jresult;
5856 }
5857
5858
5859 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
5860   float jresult ;
5861   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5862   unsigned int arg2 ;
5863   float *result = 0 ;
5864
5865   arg1 = (Dali::Vector4 *)jarg1;
5866   arg2 = (unsigned int)jarg2;
5867   {
5868     try {
5869       result = (float *) &((Dali::Vector4 const *)arg1)->operator [](arg2);
5870     } CALL_CATCH_EXCEPTION(0);
5871   }
5872
5873   jresult = *result;
5874   return jresult;
5875 }
5876
5877
5878 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_0(void * jarg1, void * jarg2) {
5879   float jresult ;
5880   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5881   Dali::Vector3 *arg2 = 0 ;
5882   float result;
5883
5884   arg1 = (Dali::Vector4 *)jarg1;
5885   arg2 = (Dali::Vector3 *)jarg2;
5886   if (!arg2) {
5887     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5888     return 0;
5889   }
5890   {
5891     try {
5892       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
5893     } CALL_CATCH_EXCEPTION(0);
5894   }
5895
5896   jresult = result;
5897   return jresult;
5898 }
5899
5900
5901 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_1(void * jarg1, void * jarg2) {
5902   float jresult ;
5903   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5904   Dali::Vector4 *arg2 = 0 ;
5905   float result;
5906
5907   arg1 = (Dali::Vector4 *)jarg1;
5908   arg2 = (Dali::Vector4 *)jarg2;
5909   if (!arg2) {
5910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5911     return 0;
5912   }
5913   {
5914     try {
5915       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector4 const &)*arg2);
5916     } CALL_CATCH_EXCEPTION(0);
5917   }
5918
5919   jresult = result;
5920   return jresult;
5921 }
5922
5923
5924 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot4(void * jarg1, void * jarg2) {
5925   float jresult ;
5926   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5927   Dali::Vector4 *arg2 = 0 ;
5928   float result;
5929
5930   arg1 = (Dali::Vector4 *)jarg1;
5931   arg2 = (Dali::Vector4 *)jarg2;
5932   if (!arg2) {
5933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5934     return 0;
5935   }
5936   {
5937     try {
5938       result = (float)((Dali::Vector4 const *)arg1)->Dot4((Dali::Vector4 const &)*arg2);
5939     } CALL_CATCH_EXCEPTION(0);
5940   }
5941
5942   jresult = result;
5943   return jresult;
5944 }
5945
5946
5947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Cross(void * jarg1, void * jarg2) {
5948   void * jresult ;
5949   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5950   Dali::Vector4 *arg2 = 0 ;
5951   Dali::Vector4 result;
5952
5953   arg1 = (Dali::Vector4 *)jarg1;
5954   arg2 = (Dali::Vector4 *)jarg2;
5955   if (!arg2) {
5956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5957     return 0;
5958   }
5959   {
5960     try {
5961       result = ((Dali::Vector4 const *)arg1)->Cross((Dali::Vector4 const &)*arg2);
5962     } CALL_CATCH_EXCEPTION(0);
5963   }
5964
5965   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
5966   return jresult;
5967 }
5968
5969
5970 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Length(void * jarg1) {
5971   float jresult ;
5972   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5973   float result;
5974
5975   arg1 = (Dali::Vector4 *)jarg1;
5976   {
5977     try {
5978       result = (float)((Dali::Vector4 const *)arg1)->Length();
5979     } CALL_CATCH_EXCEPTION(0);
5980   }
5981
5982   jresult = result;
5983   return jresult;
5984 }
5985
5986
5987 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_LengthSquared(void * jarg1) {
5988   float jresult ;
5989   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5990   float result;
5991
5992   arg1 = (Dali::Vector4 *)jarg1;
5993   {
5994     try {
5995       result = (float)((Dali::Vector4 const *)arg1)->LengthSquared();
5996     } CALL_CATCH_EXCEPTION(0);
5997   }
5998
5999   jresult = result;
6000   return jresult;
6001 }
6002
6003
6004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Normalize(void * jarg1) {
6005   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6006
6007   arg1 = (Dali::Vector4 *)jarg1;
6008   {
6009     try {
6010       (arg1)->Normalize();
6011     } CALL_CATCH_EXCEPTION();
6012   }
6013
6014 }
6015
6016
6017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Clamp(void * jarg1, void * jarg2, void * jarg3) {
6018   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6019   Dali::Vector4 *arg2 = 0 ;
6020   Dali::Vector4 *arg3 = 0 ;
6021
6022   arg1 = (Dali::Vector4 *)jarg1;
6023   arg2 = (Dali::Vector4 *)jarg2;
6024   if (!arg2) {
6025     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6026     return ;
6027   }
6028   arg3 = (Dali::Vector4 *)jarg3;
6029   if (!arg3) {
6030     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6031     return ;
6032   }
6033   {
6034     try {
6035       (arg1)->Clamp((Dali::Vector4 const &)*arg2,(Dali::Vector4 const &)*arg3);
6036     } CALL_CATCH_EXCEPTION();
6037   }
6038
6039 }
6040
6041
6042 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AsFloat__SWIG_0(void * jarg1) {
6043   void * jresult ;
6044   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6045   float *result = 0 ;
6046
6047   arg1 = (Dali::Vector4 *)jarg1;
6048   {
6049     try {
6050       result = (float *)((Dali::Vector4 const *)arg1)->AsFloat();
6051     } CALL_CATCH_EXCEPTION(0);
6052   }
6053
6054   jresult = (void *)result;
6055   return jresult;
6056 }
6057
6058
6059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_X_set(void * jarg1, float jarg2) {
6060   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6061   float arg2 ;
6062
6063   arg1 = (Dali::Vector4 *)jarg1;
6064   arg2 = (float)jarg2;
6065   if (arg1) (arg1)->x = arg2;
6066 }
6067
6068
6069 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_X_get(void * jarg1) {
6070   float jresult ;
6071   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6072   float result;
6073
6074   arg1 = (Dali::Vector4 *)jarg1;
6075   result = (float) ((arg1)->x);
6076   jresult = result;
6077   return jresult;
6078 }
6079
6080
6081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_r_set(void * jarg1, float jarg2) {
6082   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6083   float arg2 ;
6084
6085   arg1 = (Dali::Vector4 *)jarg1;
6086   arg2 = (float)jarg2;
6087   if (arg1) (arg1)->r = arg2;
6088 }
6089
6090
6091 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_r_get(void * jarg1) {
6092   float jresult ;
6093   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6094   float result;
6095
6096   arg1 = (Dali::Vector4 *)jarg1;
6097   result = (float) ((arg1)->r);
6098   jresult = result;
6099   return jresult;
6100 }
6101
6102
6103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_s_set(void * jarg1, float jarg2) {
6104   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6105   float arg2 ;
6106
6107   arg1 = (Dali::Vector4 *)jarg1;
6108   arg2 = (float)jarg2;
6109   if (arg1) (arg1)->s = arg2;
6110 }
6111
6112
6113 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_s_get(void * jarg1) {
6114   float jresult ;
6115   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6116   float result;
6117
6118   arg1 = (Dali::Vector4 *)jarg1;
6119   result = (float) ((arg1)->s);
6120   jresult = result;
6121   return jresult;
6122 }
6123
6124
6125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Y_set(void * jarg1, float jarg2) {
6126   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6127   float arg2 ;
6128
6129   arg1 = (Dali::Vector4 *)jarg1;
6130   arg2 = (float)jarg2;
6131   if (arg1) (arg1)->y = arg2;
6132 }
6133
6134
6135 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Y_get(void * jarg1) {
6136   float jresult ;
6137   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6138   float result;
6139
6140   arg1 = (Dali::Vector4 *)jarg1;
6141   result = (float) ((arg1)->y);
6142   jresult = result;
6143   return jresult;
6144 }
6145
6146
6147 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_g_set(void * jarg1, float jarg2) {
6148   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6149   float arg2 ;
6150
6151   arg1 = (Dali::Vector4 *)jarg1;
6152   arg2 = (float)jarg2;
6153   if (arg1) (arg1)->g = arg2;
6154 }
6155
6156
6157 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_g_get(void * jarg1) {
6158   float jresult ;
6159   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6160   float result;
6161
6162   arg1 = (Dali::Vector4 *)jarg1;
6163   result = (float) ((arg1)->g);
6164   jresult = result;
6165   return jresult;
6166 }
6167
6168
6169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_t_set(void * jarg1, float jarg2) {
6170   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6171   float arg2 ;
6172
6173   arg1 = (Dali::Vector4 *)jarg1;
6174   arg2 = (float)jarg2;
6175   if (arg1) (arg1)->t = arg2;
6176 }
6177
6178
6179 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_t_get(void * jarg1) {
6180   float jresult ;
6181   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6182   float result;
6183
6184   arg1 = (Dali::Vector4 *)jarg1;
6185   result = (float) ((arg1)->t);
6186   jresult = result;
6187   return jresult;
6188 }
6189
6190
6191 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Z_set(void * jarg1, float jarg2) {
6192   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6193   float arg2 ;
6194
6195   arg1 = (Dali::Vector4 *)jarg1;
6196   arg2 = (float)jarg2;
6197   if (arg1) (arg1)->z = arg2;
6198 }
6199
6200
6201 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Z_get(void * jarg1) {
6202   float jresult ;
6203   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6204   float result;
6205
6206   arg1 = (Dali::Vector4 *)jarg1;
6207   result = (float) ((arg1)->z);
6208   jresult = result;
6209   return jresult;
6210 }
6211
6212
6213 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_b_set(void * jarg1, float jarg2) {
6214   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6215   float arg2 ;
6216
6217   arg1 = (Dali::Vector4 *)jarg1;
6218   arg2 = (float)jarg2;
6219   if (arg1) (arg1)->b = arg2;
6220 }
6221
6222
6223 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_b_get(void * jarg1) {
6224   float jresult ;
6225   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6226   float result;
6227
6228   arg1 = (Dali::Vector4 *)jarg1;
6229   result = (float) ((arg1)->b);
6230   jresult = result;
6231   return jresult;
6232 }
6233
6234
6235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_p_set(void * jarg1, float jarg2) {
6236   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6237   float arg2 ;
6238
6239   arg1 = (Dali::Vector4 *)jarg1;
6240   arg2 = (float)jarg2;
6241   if (arg1) (arg1)->p = arg2;
6242 }
6243
6244
6245 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_p_get(void * jarg1) {
6246   float jresult ;
6247   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6248   float result;
6249
6250   arg1 = (Dali::Vector4 *)jarg1;
6251   result = (float) ((arg1)->p);
6252   jresult = result;
6253   return jresult;
6254 }
6255
6256
6257 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_W_set(void * jarg1, float jarg2) {
6258   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6259   float arg2 ;
6260
6261   arg1 = (Dali::Vector4 *)jarg1;
6262   arg2 = (float)jarg2;
6263   if (arg1) (arg1)->w = arg2;
6264 }
6265
6266
6267 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_W_get(void * jarg1) {
6268   float jresult ;
6269   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6270   float result;
6271
6272   arg1 = (Dali::Vector4 *)jarg1;
6273   result = (float) ((arg1)->w);
6274   jresult = result;
6275   return jresult;
6276 }
6277
6278
6279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_a_set(void * jarg1, float jarg2) {
6280   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6281   float arg2 ;
6282
6283   arg1 = (Dali::Vector4 *)jarg1;
6284   arg2 = (float)jarg2;
6285   if (arg1) (arg1)->a = arg2;
6286 }
6287
6288
6289 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_a_get(void * jarg1) {
6290   float jresult ;
6291   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6292   float result;
6293
6294   arg1 = (Dali::Vector4 *)jarg1;
6295   result = (float) ((arg1)->a);
6296   jresult = result;
6297   return jresult;
6298 }
6299
6300
6301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_q_set(void * jarg1, float jarg2) {
6302   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6303   float arg2 ;
6304
6305   arg1 = (Dali::Vector4 *)jarg1;
6306   arg2 = (float)jarg2;
6307   if (arg1) (arg1)->q = arg2;
6308 }
6309
6310
6311 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_q_get(void * jarg1) {
6312   float jresult ;
6313   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6314   float result;
6315
6316   arg1 = (Dali::Vector4 *)jarg1;
6317   result = (float) ((arg1)->q);
6318   jresult = result;
6319   return jresult;
6320 }
6321
6322
6323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector4(void * jarg1) {
6324   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6325
6326   arg1 = (Dali::Vector4 *)jarg1;
6327   {
6328     try {
6329       delete arg1;
6330     } CALL_CATCH_EXCEPTION();
6331   }
6332
6333 }
6334
6335
6336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_2(void * jarg1, void * jarg2) {
6337   void * jresult ;
6338   Dali::Vector4 *arg1 = 0 ;
6339   Dali::Vector4 *arg2 = 0 ;
6340   Dali::Vector4 result;
6341
6342   arg1 = (Dali::Vector4 *)jarg1;
6343   if (!arg1) {
6344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6345     return 0;
6346   }
6347   arg2 = (Dali::Vector4 *)jarg2;
6348   if (!arg2) {
6349     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6350     return 0;
6351   }
6352   {
6353     try {
6354       result = Dali::Min((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
6355     } CALL_CATCH_EXCEPTION(0);
6356   }
6357
6358   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6359   return jresult;
6360 }
6361
6362
6363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_2(void * jarg1, void * jarg2) {
6364   void * jresult ;
6365   Dali::Vector4 *arg1 = 0 ;
6366   Dali::Vector4 *arg2 = 0 ;
6367   Dali::Vector4 result;
6368
6369   arg1 = (Dali::Vector4 *)jarg1;
6370   if (!arg1) {
6371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6372     return 0;
6373   }
6374   arg2 = (Dali::Vector4 *)jarg2;
6375   if (!arg2) {
6376     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6377     return 0;
6378   }
6379   {
6380     try {
6381       result = Dali::Max((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
6382     } CALL_CATCH_EXCEPTION(0);
6383   }
6384
6385   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6386   return jresult;
6387 }
6388
6389
6390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
6391   void * jresult ;
6392   Dali::Vector4 *arg1 = 0 ;
6393   float *arg2 = 0 ;
6394   float *arg3 = 0 ;
6395   float temp2 ;
6396   float temp3 ;
6397   Dali::Vector4 result;
6398
6399   arg1 = (Dali::Vector4 *)jarg1;
6400   if (!arg1) {
6401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6402     return 0;
6403   }
6404   temp2 = (float)jarg2;
6405   arg2 = &temp2;
6406   temp3 = (float)jarg3;
6407   arg3 = &temp3;
6408   {
6409     try {
6410       result = Dali::Clamp((Dali::Vector4 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
6411     } CALL_CATCH_EXCEPTION(0);
6412   }
6413
6414   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6415   return jresult;
6416 }
6417
6418
6419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_0() {
6420   void * jresult ;
6421   Dali::Uint16Pair *result = 0 ;
6422
6423   {
6424     try {
6425       result = (Dali::Uint16Pair *)new Dali::Uint16Pair();
6426     } CALL_CATCH_EXCEPTION(0);
6427   }
6428
6429   jresult = (void *)result;
6430   return jresult;
6431 }
6432
6433
6434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
6435   void * jresult ;
6436   uint32_t arg1 ;
6437   uint32_t arg2 ;
6438   Dali::Uint16Pair *result = 0 ;
6439
6440   arg1 = (uint32_t)jarg1;
6441   arg2 = (uint32_t)jarg2;
6442   {
6443     try {
6444       result = (Dali::Uint16Pair *)new Dali::Uint16Pair(arg1,arg2);
6445     } CALL_CATCH_EXCEPTION(0);
6446   }
6447
6448   jresult = (void *)result;
6449   return jresult;
6450 }
6451
6452
6453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_2(void * jarg1) {
6454   void * jresult ;
6455   Dali::Uint16Pair *arg1 = 0 ;
6456   Dali::Uint16Pair *result = 0 ;
6457
6458   arg1 = (Dali::Uint16Pair *)jarg1;
6459   if (!arg1) {
6460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
6461     return 0;
6462   }
6463   {
6464     try {
6465       result = (Dali::Uint16Pair *)new Dali::Uint16Pair((Dali::Uint16Pair const &)*arg1);
6466     } CALL_CATCH_EXCEPTION(0);
6467   }
6468
6469   jresult = (void *)result;
6470   return jresult;
6471 }
6472
6473
6474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetWidth(void * jarg1, unsigned short jarg2) {
6475   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6476   uint16_t arg2 ;
6477
6478   arg1 = (Dali::Uint16Pair *)jarg1;
6479   arg2 = (uint16_t)jarg2;
6480   {
6481     try {
6482       (arg1)->SetWidth(arg2);
6483     } CALL_CATCH_EXCEPTION();
6484   }
6485
6486 }
6487
6488
6489 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetWidth(void * jarg1) {
6490   unsigned short jresult ;
6491   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6492   uint16_t result;
6493
6494   arg1 = (Dali::Uint16Pair *)jarg1;
6495   {
6496     try {
6497       result = ((Dali::Uint16Pair const *)arg1)->GetWidth();
6498     } CALL_CATCH_EXCEPTION(0);
6499   }
6500
6501   jresult = result;
6502   return jresult;
6503 }
6504
6505
6506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetHeight(void * jarg1, unsigned short jarg2) {
6507   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6508   uint16_t arg2 ;
6509
6510   arg1 = (Dali::Uint16Pair *)jarg1;
6511   arg2 = (uint16_t)jarg2;
6512   {
6513     try {
6514       (arg1)->SetHeight(arg2);
6515     } CALL_CATCH_EXCEPTION();
6516   }
6517
6518 }
6519
6520
6521 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetHeight(void * jarg1) {
6522   unsigned short jresult ;
6523   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6524   uint16_t result;
6525
6526   arg1 = (Dali::Uint16Pair *)jarg1;
6527   {
6528     try {
6529       result = ((Dali::Uint16Pair const *)arg1)->GetHeight();
6530     } CALL_CATCH_EXCEPTION(0);
6531   }
6532
6533   jresult = result;
6534   return jresult;
6535 }
6536
6537
6538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetX(void * jarg1, unsigned short jarg2) {
6539   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6540   uint16_t arg2 ;
6541
6542   arg1 = (Dali::Uint16Pair *)jarg1;
6543   arg2 = (uint16_t)jarg2;
6544   {
6545     try {
6546       (arg1)->SetX(arg2);
6547     } CALL_CATCH_EXCEPTION();
6548   }
6549
6550 }
6551
6552
6553 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetX(void * jarg1) {
6554   unsigned short jresult ;
6555   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6556   uint16_t result;
6557
6558   arg1 = (Dali::Uint16Pair *)jarg1;
6559   {
6560     try {
6561       result = ((Dali::Uint16Pair const *)arg1)->GetX();
6562     } CALL_CATCH_EXCEPTION(0);
6563   }
6564
6565   jresult = result;
6566   return jresult;
6567 }
6568
6569
6570 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetY(void * jarg1, unsigned short jarg2) {
6571   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6572   uint16_t arg2 ;
6573
6574   arg1 = (Dali::Uint16Pair *)jarg1;
6575   arg2 = (uint16_t)jarg2;
6576   {
6577     try {
6578       (arg1)->SetY(arg2);
6579     } CALL_CATCH_EXCEPTION();
6580   }
6581
6582 }
6583
6584
6585 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetY(void * jarg1) {
6586   unsigned short jresult ;
6587   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6588   uint16_t result;
6589
6590   arg1 = (Dali::Uint16Pair *)jarg1;
6591   {
6592     try {
6593       result = ((Dali::Uint16Pair const *)arg1)->GetY();
6594     } CALL_CATCH_EXCEPTION(0);
6595   }
6596
6597   jresult = result;
6598   return jresult;
6599 }
6600
6601
6602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Uint16Pair_Assign(void * jarg1, void * jarg2) {
6603   void * jresult ;
6604   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6605   Dali::Uint16Pair *arg2 = 0 ;
6606   Dali::Uint16Pair *result = 0 ;
6607
6608   arg1 = (Dali::Uint16Pair *)jarg1;
6609   arg2 = (Dali::Uint16Pair *)jarg2;
6610   if (!arg2) {
6611     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
6612     return 0;
6613   }
6614   {
6615     try {
6616       result = (Dali::Uint16Pair *) &(arg1)->operator =((Dali::Uint16Pair const &)*arg2);
6617     } CALL_CATCH_EXCEPTION(0);
6618   }
6619
6620   jresult = (void *)result;
6621   return jresult;
6622 }
6623
6624
6625 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_EqualTo(void * jarg1, void * jarg2) {
6626   unsigned int jresult ;
6627   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6628   Dali::Uint16Pair *arg2 = 0 ;
6629   bool result;
6630
6631   arg1 = (Dali::Uint16Pair *)jarg1;
6632   arg2 = (Dali::Uint16Pair *)jarg2;
6633   if (!arg2) {
6634     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
6635     return 0;
6636   }
6637   {
6638     try {
6639       result = (bool)((Dali::Uint16Pair const *)arg1)->operator ==((Dali::Uint16Pair const &)*arg2);
6640     } CALL_CATCH_EXCEPTION(0);
6641   }
6642
6643   jresult = result;
6644   return jresult;
6645 }
6646
6647
6648 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_NotEqualTo(void * jarg1, void * jarg2) {
6649   unsigned int jresult ;
6650   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6651   Dali::Uint16Pair *arg2 = 0 ;
6652   bool result;
6653
6654   arg1 = (Dali::Uint16Pair *)jarg1;
6655   arg2 = (Dali::Uint16Pair *)jarg2;
6656   if (!arg2) {
6657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
6658     return 0;
6659   }
6660   {
6661     try {
6662       result = (bool)((Dali::Uint16Pair const *)arg1)->operator !=((Dali::Uint16Pair const &)*arg2);
6663     } CALL_CATCH_EXCEPTION(0);
6664   }
6665
6666   jresult = result;
6667   return jresult;
6668 }
6669
6670
6671 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_LessThan(void * jarg1, void * jarg2) {
6672   unsigned int jresult ;
6673   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6674   Dali::Uint16Pair *arg2 = 0 ;
6675   bool result;
6676
6677   arg1 = (Dali::Uint16Pair *)jarg1;
6678   arg2 = (Dali::Uint16Pair *)jarg2;
6679   if (!arg2) {
6680     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
6681     return 0;
6682   }
6683   {
6684     try {
6685       result = (bool)((Dali::Uint16Pair const *)arg1)->operator <((Dali::Uint16Pair const &)*arg2);
6686     } CALL_CATCH_EXCEPTION(0);
6687   }
6688
6689   jresult = result;
6690   return jresult;
6691 }
6692
6693
6694 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_GreaterThan(void * jarg1, void * jarg2) {
6695   unsigned int jresult ;
6696   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6697   Dali::Uint16Pair *arg2 = 0 ;
6698   bool result;
6699
6700   arg1 = (Dali::Uint16Pair *)jarg1;
6701   arg2 = (Dali::Uint16Pair *)jarg2;
6702   if (!arg2) {
6703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
6704     return 0;
6705   }
6706   {
6707     try {
6708       result = (bool)((Dali::Uint16Pair const *)arg1)->operator >((Dali::Uint16Pair const &)*arg2);
6709     } CALL_CATCH_EXCEPTION(0);
6710   }
6711
6712   jresult = result;
6713   return jresult;
6714 }
6715
6716
6717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Uint16Pair(void * jarg1) {
6718   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6719
6720   arg1 = (Dali::Uint16Pair *)jarg1;
6721   {
6722     try {
6723       delete arg1;
6724     } CALL_CATCH_EXCEPTION();
6725   }
6726
6727 }
6728
6729
6730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_0() {
6731   void * jresult ;
6732   Dali::Degree *result = 0 ;
6733
6734   {
6735     try {
6736       result = (Dali::Degree *)new Dali::Degree();
6737     } CALL_CATCH_EXCEPTION(0);
6738   }
6739
6740   jresult = (void *)result;
6741   return jresult;
6742 }
6743
6744
6745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_1(float jarg1) {
6746   void * jresult ;
6747   float arg1 ;
6748   Dali::Degree *result = 0 ;
6749
6750   arg1 = (float)jarg1;
6751   {
6752     try {
6753       result = (Dali::Degree *)new Dali::Degree(arg1);
6754     } CALL_CATCH_EXCEPTION(0);
6755   }
6756
6757   jresult = (void *)result;
6758   return jresult;
6759 }
6760
6761
6762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_2(void * jarg1) {
6763   void * jresult ;
6764   Dali::Radian arg1 ;
6765   Dali::Radian *argp1 ;
6766   Dali::Degree *result = 0 ;
6767
6768   argp1 = (Dali::Radian *)jarg1;
6769   if (!argp1) {
6770     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
6771     return 0;
6772   }
6773   arg1 = *argp1;
6774   {
6775     try {
6776       result = (Dali::Degree *)new Dali::Degree(arg1);
6777     } CALL_CATCH_EXCEPTION(0);
6778   }
6779
6780   jresult = (void *)result;
6781   return jresult;
6782 }
6783
6784
6785 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Degree_degree_set(void * jarg1, float jarg2) {
6786   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
6787   float arg2 ;
6788
6789   arg1 = (Dali::Degree *)jarg1;
6790   arg2 = (float)jarg2;
6791   if (arg1) (arg1)->degree = arg2;
6792 }
6793
6794
6795 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Degree_degree_get(void * jarg1) {
6796   float jresult ;
6797   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
6798   float result;
6799
6800   arg1 = (Dali::Degree *)jarg1;
6801   result = (float) ((arg1)->degree);
6802   jresult = result;
6803   return jresult;
6804 }
6805
6806
6807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Degree(void * jarg1) {
6808   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
6809
6810   arg1 = (Dali::Degree *)jarg1;
6811   {
6812     try {
6813       delete arg1;
6814     } CALL_CATCH_EXCEPTION();
6815   }
6816
6817 }
6818
6819
6820 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_360_get() {
6821   void * jresult ;
6822   Dali::Radian *result = 0 ;
6823
6824   result = (Dali::Radian *)&Dali::ANGLE_360;
6825   jresult = (void *)result;
6826   return jresult;
6827 }
6828
6829
6830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_315_get() {
6831   void * jresult ;
6832   Dali::Radian *result = 0 ;
6833
6834   result = (Dali::Radian *)&Dali::ANGLE_315;
6835   jresult = (void *)result;
6836   return jresult;
6837 }
6838
6839
6840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_270_get() {
6841   void * jresult ;
6842   Dali::Radian *result = 0 ;
6843
6844   result = (Dali::Radian *)&Dali::ANGLE_270;
6845   jresult = (void *)result;
6846   return jresult;
6847 }
6848
6849
6850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_225_get() {
6851   void * jresult ;
6852   Dali::Radian *result = 0 ;
6853
6854   result = (Dali::Radian *)&Dali::ANGLE_225;
6855   jresult = (void *)result;
6856   return jresult;
6857 }
6858
6859
6860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_180_get() {
6861   void * jresult ;
6862   Dali::Radian *result = 0 ;
6863
6864   result = (Dali::Radian *)&Dali::ANGLE_180;
6865   jresult = (void *)result;
6866   return jresult;
6867 }
6868
6869
6870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_135_get() {
6871   void * jresult ;
6872   Dali::Radian *result = 0 ;
6873
6874   result = (Dali::Radian *)&Dali::ANGLE_135;
6875   jresult = (void *)result;
6876   return jresult;
6877 }
6878
6879
6880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_120_get() {
6881   void * jresult ;
6882   Dali::Radian *result = 0 ;
6883
6884   result = (Dali::Radian *)&Dali::ANGLE_120;
6885   jresult = (void *)result;
6886   return jresult;
6887 }
6888
6889
6890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_90_get() {
6891   void * jresult ;
6892   Dali::Radian *result = 0 ;
6893
6894   result = (Dali::Radian *)&Dali::ANGLE_90;
6895   jresult = (void *)result;
6896   return jresult;
6897 }
6898
6899
6900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_60_get() {
6901   void * jresult ;
6902   Dali::Radian *result = 0 ;
6903
6904   result = (Dali::Radian *)&Dali::ANGLE_60;
6905   jresult = (void *)result;
6906   return jresult;
6907 }
6908
6909
6910 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_45_get() {
6911   void * jresult ;
6912   Dali::Radian *result = 0 ;
6913
6914   result = (Dali::Radian *)&Dali::ANGLE_45;
6915   jresult = (void *)result;
6916   return jresult;
6917 }
6918
6919
6920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_30_get() {
6921   void * jresult ;
6922   Dali::Radian *result = 0 ;
6923
6924   result = (Dali::Radian *)&Dali::ANGLE_30;
6925   jresult = (void *)result;
6926   return jresult;
6927 }
6928
6929
6930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_0_get() {
6931   void * jresult ;
6932   Dali::Radian *result = 0 ;
6933
6934   result = (Dali::Radian *)&Dali::ANGLE_0;
6935   jresult = (void *)result;
6936   return jresult;
6937 }
6938
6939
6940 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_5(void * jarg1, void * jarg2) {
6941   unsigned int jresult ;
6942   Dali::Degree *arg1 = 0 ;
6943   Dali::Degree *arg2 = 0 ;
6944   bool result;
6945
6946   arg1 = (Dali::Degree *)jarg1;
6947   if (!arg1) {
6948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
6949     return 0;
6950   }
6951   arg2 = (Dali::Degree *)jarg2;
6952   if (!arg2) {
6953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
6954     return 0;
6955   }
6956   {
6957     try {
6958       result = (bool)Dali::operator ==((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
6959     } CALL_CATCH_EXCEPTION(0);
6960   }
6961
6962   jresult = result;
6963   return jresult;
6964 }
6965
6966
6967 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_4(void * jarg1, void * jarg2) {
6968   unsigned int jresult ;
6969   Dali::Degree *arg1 = 0 ;
6970   Dali::Degree *arg2 = 0 ;
6971   bool result;
6972
6973   arg1 = (Dali::Degree *)jarg1;
6974   if (!arg1) {
6975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
6976     return 0;
6977   }
6978   arg2 = (Dali::Degree *)jarg2;
6979   if (!arg2) {
6980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
6981     return 0;
6982   }
6983   {
6984     try {
6985       result = (bool)Dali::operator !=((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
6986     } CALL_CATCH_EXCEPTION(0);
6987   }
6988
6989   jresult = result;
6990   return jresult;
6991 }
6992
6993
6994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3) {
6995   void * jresult ;
6996   Dali::Degree arg1 ;
6997   float arg2 ;
6998   float arg3 ;
6999   Dali::Degree *argp1 ;
7000   Dali::Degree result;
7001
7002   argp1 = (Dali::Degree *)jarg1;
7003   if (!argp1) {
7004     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
7005     return 0;
7006   }
7007   arg1 = *argp1;
7008   arg2 = (float)jarg2;
7009   arg3 = (float)jarg3;
7010   {
7011     try {
7012       result = Dali::Clamp(arg1,arg2,arg3);
7013     } CALL_CATCH_EXCEPTION(0);
7014   }
7015
7016   jresult = new Dali::Degree((const Dali::Degree &)result);
7017   return jresult;
7018 }
7019
7020
7021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_0() {
7022   void * jresult ;
7023   Dali::Radian *result = 0 ;
7024
7025   {
7026     try {
7027       result = (Dali::Radian *)new Dali::Radian();
7028     } CALL_CATCH_EXCEPTION(0);
7029   }
7030
7031   jresult = (void *)result;
7032   return jresult;
7033 }
7034
7035
7036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_1(float jarg1) {
7037   void * jresult ;
7038   float arg1 ;
7039   Dali::Radian *result = 0 ;
7040
7041   arg1 = (float)jarg1;
7042   {
7043     try {
7044       result = (Dali::Radian *)new Dali::Radian(arg1);
7045     } CALL_CATCH_EXCEPTION(0);
7046   }
7047
7048   jresult = (void *)result;
7049   return jresult;
7050 }
7051
7052
7053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_2(void * jarg1) {
7054   void * jresult ;
7055   Dali::Degree arg1 ;
7056   Dali::Degree *argp1 ;
7057   Dali::Radian *result = 0 ;
7058
7059   argp1 = (Dali::Degree *)jarg1;
7060   if (!argp1) {
7061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
7062     return 0;
7063   }
7064   arg1 = *argp1;
7065   {
7066     try {
7067       result = (Dali::Radian *)new Dali::Radian(arg1);
7068     } CALL_CATCH_EXCEPTION(0);
7069   }
7070
7071   jresult = (void *)result;
7072   return jresult;
7073 }
7074
7075
7076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_0(void * jarg1, float jarg2) {
7077   void * jresult ;
7078   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
7079   float arg2 ;
7080   Dali::Radian *result = 0 ;
7081
7082   arg1 = (Dali::Radian *)jarg1;
7083   arg2 = (float)jarg2;
7084   {
7085     try {
7086       result = (Dali::Radian *) &(arg1)->operator =(arg2);
7087     } CALL_CATCH_EXCEPTION(0);
7088   }
7089
7090   jresult = (void *)result;
7091   return jresult;
7092 }
7093
7094
7095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_1(void * jarg1, void * jarg2) {
7096   void * jresult ;
7097   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
7098   Dali::Degree arg2 ;
7099   Dali::Degree *argp2 ;
7100   Dali::Radian *result = 0 ;
7101
7102   arg1 = (Dali::Radian *)jarg1;
7103   argp2 = (Dali::Degree *)jarg2;
7104   if (!argp2) {
7105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
7106     return 0;
7107   }
7108   arg2 = *argp2;
7109   {
7110     try {
7111       result = (Dali::Radian *) &(arg1)->operator =(arg2);
7112     } CALL_CATCH_EXCEPTION(0);
7113   }
7114
7115   jresult = (void *)result;
7116   return jresult;
7117 }
7118
7119
7120 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_ConvertToFloat(void * jarg1) {
7121   float jresult ;
7122   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
7123   float result;
7124
7125   arg1 = (Dali::Radian *)jarg1;
7126   {
7127     try {
7128       result = (float)((Dali::Radian const *)arg1)->operator float();
7129     } CALL_CATCH_EXCEPTION(0);
7130   }
7131
7132   jresult = result;
7133   return jresult;
7134 }
7135
7136
7137 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Radian_radian_set(void * jarg1, float jarg2) {
7138   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
7139   float arg2 ;
7140
7141   arg1 = (Dali::Radian *)jarg1;
7142   arg2 = (float)jarg2;
7143   if (arg1) (arg1)->radian = arg2;
7144 }
7145
7146
7147 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_radian_get(void * jarg1) {
7148   float jresult ;
7149   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
7150   float result;
7151
7152   arg1 = (Dali::Radian *)jarg1;
7153   result = (float) ((arg1)->radian);
7154   jresult = result;
7155   return jresult;
7156 }
7157
7158
7159 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Radian(void * jarg1) {
7160   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
7161
7162   arg1 = (Dali::Radian *)jarg1;
7163   {
7164     try {
7165       delete arg1;
7166     } CALL_CATCH_EXCEPTION();
7167   }
7168
7169 }
7170
7171
7172 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_6(void * jarg1, void * jarg2) {
7173   unsigned int jresult ;
7174   Dali::Radian arg1 ;
7175   Dali::Radian arg2 ;
7176   Dali::Radian *argp1 ;
7177   Dali::Radian *argp2 ;
7178   bool result;
7179
7180   argp1 = (Dali::Radian *)jarg1;
7181   if (!argp1) {
7182     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7183     return 0;
7184   }
7185   arg1 = *argp1;
7186   argp2 = (Dali::Radian *)jarg2;
7187   if (!argp2) {
7188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7189     return 0;
7190   }
7191   arg2 = *argp2;
7192   {
7193     try {
7194       result = (bool)Dali::operator ==(arg1,arg2);
7195     } CALL_CATCH_EXCEPTION(0);
7196   }
7197
7198   jresult = result;
7199   return jresult;
7200 }
7201
7202
7203 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_5(void * jarg1, void * jarg2) {
7204   unsigned int jresult ;
7205   Dali::Radian arg1 ;
7206   Dali::Radian arg2 ;
7207   Dali::Radian *argp1 ;
7208   Dali::Radian *argp2 ;
7209   bool result;
7210
7211   argp1 = (Dali::Radian *)jarg1;
7212   if (!argp1) {
7213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7214     return 0;
7215   }
7216   arg1 = *argp1;
7217   argp2 = (Dali::Radian *)jarg2;
7218   if (!argp2) {
7219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7220     return 0;
7221   }
7222   arg2 = *argp2;
7223   {
7224     try {
7225       result = (bool)Dali::operator !=(arg1,arg2);
7226     } CALL_CATCH_EXCEPTION(0);
7227   }
7228
7229   jresult = result;
7230   return jresult;
7231 }
7232
7233
7234 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_7(void * jarg1, void * jarg2) {
7235   unsigned int jresult ;
7236   Dali::Radian arg1 ;
7237   Dali::Degree arg2 ;
7238   Dali::Radian *argp1 ;
7239   Dali::Degree *argp2 ;
7240   bool result;
7241
7242   argp1 = (Dali::Radian *)jarg1;
7243   if (!argp1) {
7244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7245     return 0;
7246   }
7247   arg1 = *argp1;
7248   argp2 = (Dali::Degree *)jarg2;
7249   if (!argp2) {
7250     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
7251     return 0;
7252   }
7253   arg2 = *argp2;
7254   {
7255     try {
7256       result = (bool)Dali::operator ==(arg1,arg2);
7257     } CALL_CATCH_EXCEPTION(0);
7258   }
7259
7260   jresult = result;
7261   return jresult;
7262 }
7263
7264
7265 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_6(void * jarg1, void * jarg2) {
7266   unsigned int jresult ;
7267   Dali::Radian arg1 ;
7268   Dali::Degree arg2 ;
7269   Dali::Radian *argp1 ;
7270   Dali::Degree *argp2 ;
7271   bool result;
7272
7273   argp1 = (Dali::Radian *)jarg1;
7274   if (!argp1) {
7275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7276     return 0;
7277   }
7278   arg1 = *argp1;
7279   argp2 = (Dali::Degree *)jarg2;
7280   if (!argp2) {
7281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
7282     return 0;
7283   }
7284   arg2 = *argp2;
7285   {
7286     try {
7287       result = (bool)Dali::operator !=(arg1,arg2);
7288     } CALL_CATCH_EXCEPTION(0);
7289   }
7290
7291   jresult = result;
7292   return jresult;
7293 }
7294
7295
7296 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_8(void * jarg1, void * jarg2) {
7297   unsigned int jresult ;
7298   Dali::Degree arg1 ;
7299   Dali::Radian arg2 ;
7300   Dali::Degree *argp1 ;
7301   Dali::Radian *argp2 ;
7302   bool result;
7303
7304   argp1 = (Dali::Degree *)jarg1;
7305   if (!argp1) {
7306     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
7307     return 0;
7308   }
7309   arg1 = *argp1;
7310   argp2 = (Dali::Radian *)jarg2;
7311   if (!argp2) {
7312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7313     return 0;
7314   }
7315   arg2 = *argp2;
7316   {
7317     try {
7318       result = (bool)Dali::operator ==(arg1,arg2);
7319     } CALL_CATCH_EXCEPTION(0);
7320   }
7321
7322   jresult = result;
7323   return jresult;
7324 }
7325
7326
7327 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_7(void * jarg1, void * jarg2) {
7328   unsigned int jresult ;
7329   Dali::Degree arg1 ;
7330   Dali::Radian arg2 ;
7331   Dali::Degree *argp1 ;
7332   Dali::Radian *argp2 ;
7333   bool result;
7334
7335   argp1 = (Dali::Degree *)jarg1;
7336   if (!argp1) {
7337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
7338     return 0;
7339   }
7340   arg1 = *argp1;
7341   argp2 = (Dali::Radian *)jarg2;
7342   if (!argp2) {
7343     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7344     return 0;
7345   }
7346   arg2 = *argp2;
7347   {
7348     try {
7349       result = (bool)Dali::operator !=(arg1,arg2);
7350     } CALL_CATCH_EXCEPTION(0);
7351   }
7352
7353   jresult = result;
7354   return jresult;
7355 }
7356
7357
7358 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_0(void * jarg1, void * jarg2) {
7359   unsigned int jresult ;
7360   Dali::Radian arg1 ;
7361   Dali::Radian arg2 ;
7362   Dali::Radian *argp1 ;
7363   Dali::Radian *argp2 ;
7364   bool result;
7365
7366   argp1 = (Dali::Radian *)jarg1;
7367   if (!argp1) {
7368     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7369     return 0;
7370   }
7371   arg1 = *argp1;
7372   argp2 = (Dali::Radian *)jarg2;
7373   if (!argp2) {
7374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7375     return 0;
7376   }
7377   arg2 = *argp2;
7378   {
7379     try {
7380       result = (bool)Dali::operator >(arg1,arg2);
7381     } CALL_CATCH_EXCEPTION(0);
7382   }
7383
7384   jresult = result;
7385   return jresult;
7386 }
7387
7388
7389 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_1(void * jarg1, void * jarg2) {
7390   unsigned int jresult ;
7391   Dali::Radian arg1 ;
7392   Dali::Degree arg2 ;
7393   Dali::Radian *argp1 ;
7394   Dali::Degree *argp2 ;
7395   bool result;
7396
7397   argp1 = (Dali::Radian *)jarg1;
7398   if (!argp1) {
7399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7400     return 0;
7401   }
7402   arg1 = *argp1;
7403   argp2 = (Dali::Degree *)jarg2;
7404   if (!argp2) {
7405     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
7406     return 0;
7407   }
7408   arg2 = *argp2;
7409   {
7410     try {
7411       result = (bool)Dali::operator >(arg1,arg2);
7412     } CALL_CATCH_EXCEPTION(0);
7413   }
7414
7415   jresult = result;
7416   return jresult;
7417 }
7418
7419
7420 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_2(void * jarg1, void * jarg2) {
7421   unsigned int jresult ;
7422   Dali::Degree arg1 ;
7423   Dali::Radian arg2 ;
7424   Dali::Degree *argp1 ;
7425   Dali::Radian *argp2 ;
7426   bool result;
7427
7428   argp1 = (Dali::Degree *)jarg1;
7429   if (!argp1) {
7430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
7431     return 0;
7432   }
7433   arg1 = *argp1;
7434   argp2 = (Dali::Radian *)jarg2;
7435   if (!argp2) {
7436     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7437     return 0;
7438   }
7439   arg2 = *argp2;
7440   {
7441     try {
7442       result = (bool)Dali::operator >(arg1,arg2);
7443     } CALL_CATCH_EXCEPTION(0);
7444   }
7445
7446   jresult = result;
7447   return jresult;
7448 }
7449
7450
7451 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_0(void * jarg1, void * jarg2) {
7452   unsigned int jresult ;
7453   Dali::Radian arg1 ;
7454   Dali::Radian arg2 ;
7455   Dali::Radian *argp1 ;
7456   Dali::Radian *argp2 ;
7457   bool result;
7458
7459   argp1 = (Dali::Radian *)jarg1;
7460   if (!argp1) {
7461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7462     return 0;
7463   }
7464   arg1 = *argp1;
7465   argp2 = (Dali::Radian *)jarg2;
7466   if (!argp2) {
7467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7468     return 0;
7469   }
7470   arg2 = *argp2;
7471   {
7472     try {
7473       result = (bool)Dali::operator <(arg1,arg2);
7474     } CALL_CATCH_EXCEPTION(0);
7475   }
7476
7477   jresult = result;
7478   return jresult;
7479 }
7480
7481
7482 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_1(void * jarg1, void * jarg2) {
7483   unsigned int jresult ;
7484   Dali::Radian arg1 ;
7485   Dali::Degree arg2 ;
7486   Dali::Radian *argp1 ;
7487   Dali::Degree *argp2 ;
7488   bool result;
7489
7490   argp1 = (Dali::Radian *)jarg1;
7491   if (!argp1) {
7492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7493     return 0;
7494   }
7495   arg1 = *argp1;
7496   argp2 = (Dali::Degree *)jarg2;
7497   if (!argp2) {
7498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
7499     return 0;
7500   }
7501   arg2 = *argp2;
7502   {
7503     try {
7504       result = (bool)Dali::operator <(arg1,arg2);
7505     } CALL_CATCH_EXCEPTION(0);
7506   }
7507
7508   jresult = result;
7509   return jresult;
7510 }
7511
7512
7513 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_2(void * jarg1, void * jarg2) {
7514   unsigned int jresult ;
7515   Dali::Degree arg1 ;
7516   Dali::Radian arg2 ;
7517   Dali::Degree *argp1 ;
7518   Dali::Radian *argp2 ;
7519   bool result;
7520
7521   argp1 = (Dali::Degree *)jarg1;
7522   if (!argp1) {
7523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
7524     return 0;
7525   }
7526   arg1 = *argp1;
7527   argp2 = (Dali::Radian *)jarg2;
7528   if (!argp2) {
7529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7530     return 0;
7531   }
7532   arg2 = *argp2;
7533   {
7534     try {
7535       result = (bool)Dali::operator <(arg1,arg2);
7536     } CALL_CATCH_EXCEPTION(0);
7537   }
7538
7539   jresult = result;
7540   return jresult;
7541 }
7542
7543
7544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Multiply(void * jarg1, float jarg2) {
7545   void * jresult ;
7546   Dali::Radian arg1 ;
7547   float arg2 ;
7548   Dali::Radian *argp1 ;
7549   Dali::Radian result;
7550
7551   argp1 = (Dali::Radian *)jarg1;
7552   if (!argp1) {
7553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7554     return 0;
7555   }
7556   arg1 = *argp1;
7557   arg2 = (float)jarg2;
7558   {
7559     try {
7560       result = Dali::operator *(arg1,arg2);
7561     } CALL_CATCH_EXCEPTION(0);
7562   }
7563
7564   jresult = new Dali::Radian((const Dali::Radian &)result);
7565   return jresult;
7566 }
7567
7568
7569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Subtract(void * jarg1) {
7570   void * jresult ;
7571   Dali::Radian arg1 ;
7572   Dali::Radian *argp1 ;
7573   Dali::Radian result;
7574
7575   argp1 = (Dali::Radian *)jarg1;
7576   if (!argp1) {
7577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7578     return 0;
7579   }
7580   arg1 = *argp1;
7581   {
7582     try {
7583       result = Dali::operator -(arg1);
7584     } CALL_CATCH_EXCEPTION(0);
7585   }
7586
7587   jresult = new Dali::Radian((const Dali::Radian &)result);
7588   return jresult;
7589 }
7590
7591
7592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_4(void * jarg1, float jarg2, float jarg3) {
7593   void * jresult ;
7594   Dali::Radian arg1 ;
7595   float arg2 ;
7596   float arg3 ;
7597   Dali::Radian *argp1 ;
7598   Dali::Radian result;
7599
7600   argp1 = (Dali::Radian *)jarg1;
7601   if (!argp1) {
7602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7603     return 0;
7604   }
7605   arg1 = *argp1;
7606   arg2 = (float)jarg2;
7607   arg3 = (float)jarg3;
7608   {
7609     try {
7610       result = Dali::Clamp(arg1,arg2,arg3);
7611     } CALL_CATCH_EXCEPTION(0);
7612   }
7613
7614   jresult = new Dali::Radian((const Dali::Radian &)result);
7615   return jresult;
7616 }
7617
7618
7619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_0() {
7620   void * jresult ;
7621   Dali::Quaternion *result = 0 ;
7622
7623   {
7624     try {
7625       result = (Dali::Quaternion *)new Dali::Quaternion();
7626     } CALL_CATCH_EXCEPTION(0);
7627   }
7628
7629   jresult = (void *)result;
7630   return jresult;
7631 }
7632
7633
7634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_1(void * jarg1, void * jarg2) {
7635   void * jresult ;
7636   Dali::Radian arg1 ;
7637   Dali::Vector3 *arg2 = 0 ;
7638   Dali::Radian *argp1 ;
7639   Dali::Quaternion *result = 0 ;
7640
7641   argp1 = (Dali::Radian *)jarg1;
7642   if (!argp1) {
7643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7644     return 0;
7645   }
7646   arg1 = *argp1;
7647   arg2 = (Dali::Vector3 *)jarg2;
7648   if (!arg2) {
7649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7650     return 0;
7651   }
7652   {
7653     try {
7654       result = (Dali::Quaternion *)new Dali::Quaternion(arg1,(Dali::Vector3 const &)*arg2);
7655     } CALL_CATCH_EXCEPTION(0);
7656   }
7657
7658   jresult = (void *)result;
7659   return jresult;
7660 }
7661
7662
7663 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rotation(void * jarg1) {
7664   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
7665
7666   arg1 = (Dali::Quaternion *)jarg1;
7667   {
7668     try {
7669       delete arg1;
7670     } CALL_CATCH_EXCEPTION();
7671   }
7672
7673 }
7674
7675
7676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_IDENTITY_get() {
7677   void * jresult ;
7678   Dali::Quaternion *result = 0 ;
7679
7680   result = (Dali::Quaternion *)&Dali::Quaternion::IDENTITY;
7681   jresult = (void *)result;
7682   return jresult;
7683 }
7684
7685
7686 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_IsIdentity(void * jarg1) {
7687   unsigned int jresult ;
7688   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
7689   bool result;
7690
7691   arg1 = (Dali::Quaternion *)jarg1;
7692   {
7693     try {
7694       result = (bool)((Dali::Quaternion const *)arg1)->IsIdentity();
7695     } CALL_CATCH_EXCEPTION(0);
7696   }
7697
7698   jresult = result;
7699   return jresult;
7700 }
7701
7702
7703 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_GetAxisAngle(void * jarg1, void * jarg2, void * jarg3) {
7704   unsigned int jresult ;
7705   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
7706   Dali::Vector3 *arg2 = 0 ;
7707   Dali::Radian *arg3 = 0 ;
7708   bool result;
7709
7710   arg1 = (Dali::Quaternion *)jarg1;
7711   arg2 = (Dali::Vector3 *)jarg2;
7712   if (!arg2) {
7713     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
7714     return 0;
7715   }
7716   arg3 = (Dali::Radian *)jarg3;
7717   if (!arg3) {
7718     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian & type is null", 0);
7719     return 0;
7720   }
7721   {
7722     try {
7723       result = (bool)((Dali::Quaternion const *)arg1)->ToAxisAngle(*arg2,*arg3);
7724     } CALL_CATCH_EXCEPTION(0);
7725   }
7726
7727   jresult = result;
7728   return jresult;
7729 }
7730
7731
7732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Add(void * jarg1, void * jarg2) {
7733   void * jresult ;
7734   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
7735   Dali::Quaternion *arg2 = 0 ;
7736   Dali::Quaternion result;
7737
7738   arg1 = (Dali::Quaternion *)jarg1;
7739   arg2 = (Dali::Quaternion *)jarg2;
7740   if (!arg2) {
7741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
7742     return 0;
7743   }
7744   {
7745     try {
7746       result = ((Dali::Quaternion const *)arg1)->operator +((Dali::Quaternion const &)*arg2);
7747     } CALL_CATCH_EXCEPTION(0);
7748   }
7749
7750   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
7751   return jresult;
7752 }
7753
7754
7755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_0(void * jarg1, void * jarg2) {
7756   void * jresult ;
7757   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
7758   Dali::Quaternion *arg2 = 0 ;
7759   Dali::Quaternion result;
7760
7761   arg1 = (Dali::Quaternion *)jarg1;
7762   arg2 = (Dali::Quaternion *)jarg2;
7763   if (!arg2) {
7764     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
7765     return 0;
7766   }
7767   {
7768     try {
7769       result = ((Dali::Quaternion const *)arg1)->operator -((Dali::Quaternion const &)*arg2);
7770     } CALL_CATCH_EXCEPTION(0);
7771   }
7772
7773   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
7774   return jresult;
7775 }
7776
7777
7778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_0(void * jarg1, void * jarg2) {
7779   void * jresult ;
7780   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
7781   Dali::Quaternion *arg2 = 0 ;
7782   Dali::Quaternion result;
7783
7784   arg1 = (Dali::Quaternion *)jarg1;
7785   arg2 = (Dali::Quaternion *)jarg2;
7786   if (!arg2) {
7787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
7788     return 0;
7789   }
7790   {
7791     try {
7792       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Quaternion const &)*arg2);
7793     } CALL_CATCH_EXCEPTION(0);
7794   }
7795
7796   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
7797   return jresult;
7798 }
7799
7800
7801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_1(void * jarg1, void * jarg2) {
7802   void * jresult ;
7803   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
7804   Dali::Vector3 *arg2 = 0 ;
7805   Dali::Vector3 result;
7806
7807   arg1 = (Dali::Quaternion *)jarg1;
7808   arg2 = (Dali::Vector3 *)jarg2;
7809   if (!arg2) {
7810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7811     return 0;
7812   }
7813   {
7814     try {
7815       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
7816     } CALL_CATCH_EXCEPTION(0);
7817   }
7818
7819   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7820   return jresult;
7821 }
7822
7823
7824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_0(void * jarg1, void * jarg2) {
7825   void * jresult ;
7826   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
7827   Dali::Quaternion *arg2 = 0 ;
7828   Dali::Quaternion result;
7829
7830   arg1 = (Dali::Quaternion *)jarg1;
7831   arg2 = (Dali::Quaternion *)jarg2;
7832   if (!arg2) {
7833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
7834     return 0;
7835   }
7836   {
7837     try {
7838       result = ((Dali::Quaternion const *)arg1)->operator /((Dali::Quaternion const &)*arg2);
7839     } CALL_CATCH_EXCEPTION(0);
7840   }
7841
7842   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
7843   return jresult;
7844 }
7845
7846
7847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_2(void * jarg1, float jarg2) {
7848   void * jresult ;
7849   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
7850   float arg2 ;
7851   Dali::Quaternion result;
7852
7853   arg1 = (Dali::Quaternion *)jarg1;
7854   arg2 = (float)jarg2;
7855   {
7856     try {
7857       result = ((Dali::Quaternion const *)arg1)->operator *(arg2);
7858     } CALL_CATCH_EXCEPTION(0);
7859   }
7860
7861   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
7862   return jresult;
7863 }
7864
7865
7866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_1(void * jarg1, float jarg2) {
7867   void * jresult ;
7868   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
7869   float arg2 ;
7870   Dali::Quaternion result;
7871
7872   arg1 = (Dali::Quaternion *)jarg1;
7873   arg2 = (float)jarg2;
7874   {
7875     try {
7876       result = ((Dali::Quaternion const *)arg1)->operator /(arg2);
7877     } CALL_CATCH_EXCEPTION(0);
7878   }
7879
7880   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
7881   return jresult;
7882 }
7883
7884
7885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_1(void * jarg1) {
7886   void * jresult ;
7887   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
7888   Dali::Quaternion result;
7889
7890   arg1 = (Dali::Quaternion *)jarg1;
7891   {
7892     try {
7893       result = ((Dali::Quaternion const *)arg1)->operator -();
7894     } CALL_CATCH_EXCEPTION(0);
7895   }
7896
7897   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
7898   return jresult;
7899 }
7900
7901
7902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_AddAssign(void * jarg1, void * jarg2) {
7903   void * jresult ;
7904   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
7905   Dali::Quaternion *arg2 = 0 ;
7906   Dali::Quaternion *result = 0 ;
7907
7908   arg1 = (Dali::Quaternion *)jarg1;
7909   arg2 = (Dali::Quaternion *)jarg2;
7910   if (!arg2) {
7911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
7912     return 0;
7913   }
7914   {
7915     try {
7916       result = (Dali::Quaternion *) &(arg1)->operator +=((Dali::Quaternion const &)*arg2);
7917     } CALL_CATCH_EXCEPTION(0);
7918   }
7919
7920   jresult = (void *)result;
7921   return jresult;
7922 }
7923
7924
7925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SubtractAssign(void * jarg1, void * jarg2) {
7926   void * jresult ;
7927   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
7928   Dali::Quaternion *arg2 = 0 ;
7929   Dali::Quaternion *result = 0 ;
7930
7931   arg1 = (Dali::Quaternion *)jarg1;
7932   arg2 = (Dali::Quaternion *)jarg2;
7933   if (!arg2) {
7934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
7935     return 0;
7936   }
7937   {
7938     try {
7939       result = (Dali::Quaternion *) &(arg1)->operator -=((Dali::Quaternion const &)*arg2);
7940     } CALL_CATCH_EXCEPTION(0);
7941   }
7942
7943   jresult = (void *)result;
7944   return jresult;
7945 }
7946
7947
7948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
7949   void * jresult ;
7950   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
7951   Dali::Quaternion *arg2 = 0 ;
7952   Dali::Quaternion *result = 0 ;
7953
7954   arg1 = (Dali::Quaternion *)jarg1;
7955   arg2 = (Dali::Quaternion *)jarg2;
7956   if (!arg2) {
7957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
7958     return 0;
7959   }
7960   {
7961     try {
7962       result = (Dali::Quaternion *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
7963     } CALL_CATCH_EXCEPTION(0);
7964   }
7965
7966   jresult = (void *)result;
7967   return jresult;
7968 }
7969
7970
7971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
7972   void * jresult ;
7973   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
7974   float arg2 ;
7975   Dali::Quaternion *result = 0 ;
7976
7977   arg1 = (Dali::Quaternion *)jarg1;
7978   arg2 = (float)jarg2;
7979   {
7980     try {
7981       result = (Dali::Quaternion *) &(arg1)->operator *=(arg2);
7982     } CALL_CATCH_EXCEPTION(0);
7983   }
7984
7985   jresult = (void *)result;
7986   return jresult;
7987 }
7988
7989
7990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_DivideAssign(void * jarg1, float jarg2) {
7991   void * jresult ;
7992   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
7993   float arg2 ;
7994   Dali::Quaternion *result = 0 ;
7995
7996   arg1 = (Dali::Quaternion *)jarg1;
7997   arg2 = (float)jarg2;
7998   {
7999     try {
8000       result = (Dali::Quaternion *) &(arg1)->operator /=(arg2);
8001     } CALL_CATCH_EXCEPTION(0);
8002   }
8003
8004   jresult = (void *)result;
8005   return jresult;
8006 }
8007
8008
8009 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_EqualTo(void * jarg1, void * jarg2) {
8010   unsigned int jresult ;
8011   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
8012   Dali::Quaternion *arg2 = 0 ;
8013   bool result;
8014
8015   arg1 = (Dali::Quaternion *)jarg1;
8016   arg2 = (Dali::Quaternion *)jarg2;
8017   if (!arg2) {
8018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
8019     return 0;
8020   }
8021   {
8022     try {
8023       result = (bool)((Dali::Quaternion const *)arg1)->operator ==((Dali::Quaternion const &)*arg2);
8024     } CALL_CATCH_EXCEPTION(0);
8025   }
8026
8027   jresult = result;
8028   return jresult;
8029 }
8030
8031
8032 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_NotEqualTo(void * jarg1, void * jarg2) {
8033   unsigned int jresult ;
8034   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
8035   Dali::Quaternion *arg2 = 0 ;
8036   bool result;
8037
8038   arg1 = (Dali::Quaternion *)jarg1;
8039   arg2 = (Dali::Quaternion *)jarg2;
8040   if (!arg2) {
8041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
8042     return 0;
8043   }
8044   {
8045     try {
8046       result = (bool)((Dali::Quaternion const *)arg1)->operator !=((Dali::Quaternion const &)*arg2);
8047     } CALL_CATCH_EXCEPTION(0);
8048   }
8049
8050   jresult = result;
8051   return jresult;
8052 }
8053
8054
8055 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Length(void * jarg1) {
8056   float jresult ;
8057   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
8058   float result;
8059
8060   arg1 = (Dali::Quaternion *)jarg1;
8061   {
8062     try {
8063       result = (float)((Dali::Quaternion const *)arg1)->Length();
8064     } CALL_CATCH_EXCEPTION(0);
8065   }
8066
8067   jresult = result;
8068   return jresult;
8069 }
8070
8071
8072 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_LengthSquared(void * jarg1) {
8073   float jresult ;
8074   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
8075   float result;
8076
8077   arg1 = (Dali::Quaternion *)jarg1;
8078   {
8079     try {
8080       result = (float)((Dali::Quaternion const *)arg1)->LengthSquared();
8081     } CALL_CATCH_EXCEPTION(0);
8082   }
8083
8084   jresult = result;
8085   return jresult;
8086 }
8087
8088
8089 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Normalize(void * jarg1) {
8090   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
8091
8092   arg1 = (Dali::Quaternion *)jarg1;
8093   {
8094     try {
8095       (arg1)->Normalize();
8096     } CALL_CATCH_EXCEPTION();
8097   }
8098
8099 }
8100
8101
8102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Normalized(void * jarg1) {
8103   void * jresult ;
8104   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
8105   Dali::Quaternion result;
8106
8107   arg1 = (Dali::Quaternion *)jarg1;
8108   {
8109     try {
8110       result = ((Dali::Quaternion const *)arg1)->Normalized();
8111     } CALL_CATCH_EXCEPTION(0);
8112   }
8113
8114   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
8115   return jresult;
8116 }
8117
8118
8119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Conjugate(void * jarg1) {
8120   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
8121
8122   arg1 = (Dali::Quaternion *)jarg1;
8123   {
8124     try {
8125       (arg1)->Conjugate();
8126     } CALL_CATCH_EXCEPTION();
8127   }
8128
8129 }
8130
8131
8132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Invert(void * jarg1) {
8133   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
8134
8135   arg1 = (Dali::Quaternion *)jarg1;
8136   {
8137     try {
8138       (arg1)->Invert();
8139     } CALL_CATCH_EXCEPTION();
8140   }
8141
8142 }
8143
8144
8145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Log(void * jarg1) {
8146   void * jresult ;
8147   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
8148   Dali::Quaternion result;
8149
8150   arg1 = (Dali::Quaternion *)jarg1;
8151   {
8152     try {
8153       result = ((Dali::Quaternion const *)arg1)->Log();
8154     } CALL_CATCH_EXCEPTION(0);
8155   }
8156
8157   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
8158   return jresult;
8159 }
8160
8161
8162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Exp(void * jarg1) {
8163   void * jresult ;
8164   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
8165   Dali::Quaternion result;
8166
8167   arg1 = (Dali::Quaternion *)jarg1;
8168   {
8169     try {
8170       result = ((Dali::Quaternion const *)arg1)->Exp();
8171     } CALL_CATCH_EXCEPTION(0);
8172   }
8173
8174   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
8175   return jresult;
8176 }
8177
8178
8179 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Dot(void * jarg1, void * jarg2) {
8180   float jresult ;
8181   Dali::Quaternion *arg1 = 0 ;
8182   Dali::Quaternion *arg2 = 0 ;
8183   float result;
8184
8185   arg1 = (Dali::Quaternion *)jarg1;
8186   if (!arg1) {
8187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
8188     return 0;
8189   }
8190   arg2 = (Dali::Quaternion *)jarg2;
8191   if (!arg2) {
8192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
8193     return 0;
8194   }
8195   {
8196     try {
8197       result = (float)Dali::Quaternion::Dot((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
8198     } CALL_CATCH_EXCEPTION(0);
8199   }
8200
8201   jresult = result;
8202   return jresult;
8203 }
8204
8205
8206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Lerp(void * jarg1, void * jarg2, float jarg3) {
8207   void * jresult ;
8208   Dali::Quaternion *arg1 = 0 ;
8209   Dali::Quaternion *arg2 = 0 ;
8210   float arg3 ;
8211   Dali::Quaternion result;
8212
8213   arg1 = (Dali::Quaternion *)jarg1;
8214   if (!arg1) {
8215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
8216     return 0;
8217   }
8218   arg2 = (Dali::Quaternion *)jarg2;
8219   if (!arg2) {
8220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
8221     return 0;
8222   }
8223   arg3 = (float)jarg3;
8224   {
8225     try {
8226       result = Dali::Quaternion::Lerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
8227     } CALL_CATCH_EXCEPTION(0);
8228   }
8229
8230   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
8231   return jresult;
8232 }
8233
8234
8235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Slerp(void * jarg1, void * jarg2, float jarg3) {
8236   void * jresult ;
8237   Dali::Quaternion *arg1 = 0 ;
8238   Dali::Quaternion *arg2 = 0 ;
8239   float arg3 ;
8240   Dali::Quaternion result;
8241
8242   arg1 = (Dali::Quaternion *)jarg1;
8243   if (!arg1) {
8244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
8245     return 0;
8246   }
8247   arg2 = (Dali::Quaternion *)jarg2;
8248   if (!arg2) {
8249     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
8250     return 0;
8251   }
8252   arg3 = (float)jarg3;
8253   {
8254     try {
8255       result = Dali::Quaternion::Slerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
8256     } CALL_CATCH_EXCEPTION(0);
8257   }
8258
8259   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
8260   return jresult;
8261 }
8262
8263
8264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SlerpNoInvert(void * jarg1, void * jarg2, float jarg3) {
8265   void * jresult ;
8266   Dali::Quaternion *arg1 = 0 ;
8267   Dali::Quaternion *arg2 = 0 ;
8268   float arg3 ;
8269   Dali::Quaternion result;
8270
8271   arg1 = (Dali::Quaternion *)jarg1;
8272   if (!arg1) {
8273     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
8274     return 0;
8275   }
8276   arg2 = (Dali::Quaternion *)jarg2;
8277   if (!arg2) {
8278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
8279     return 0;
8280   }
8281   arg3 = (float)jarg3;
8282   {
8283     try {
8284       result = Dali::Quaternion::SlerpNoInvert((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
8285     } CALL_CATCH_EXCEPTION(0);
8286   }
8287
8288   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
8289   return jresult;
8290 }
8291
8292
8293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Squad(void * jarg1, void * jarg2, void * jarg3, void * jarg4, float jarg5) {
8294   void * jresult ;
8295   Dali::Quaternion *arg1 = 0 ;
8296   Dali::Quaternion *arg2 = 0 ;
8297   Dali::Quaternion *arg3 = 0 ;
8298   Dali::Quaternion *arg4 = 0 ;
8299   float arg5 ;
8300   Dali::Quaternion result;
8301
8302   arg1 = (Dali::Quaternion *)jarg1;
8303   if (!arg1) {
8304     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
8305     return 0;
8306   }
8307   arg2 = (Dali::Quaternion *)jarg2;
8308   if (!arg2) {
8309     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
8310     return 0;
8311   }
8312   arg3 = (Dali::Quaternion *)jarg3;
8313   if (!arg3) {
8314     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
8315     return 0;
8316   }
8317   arg4 = (Dali::Quaternion *)jarg4;
8318   if (!arg4) {
8319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
8320     return 0;
8321   }
8322   arg5 = (float)jarg5;
8323   {
8324     try {
8325       result = Dali::Quaternion::Squad((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Quaternion const &)*arg4,arg5);
8326     } CALL_CATCH_EXCEPTION(0);
8327   }
8328
8329   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
8330   return jresult;
8331 }
8332
8333
8334 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_AngleBetween(void * jarg1, void * jarg2) {
8335   float jresult ;
8336   Dali::Quaternion *arg1 = 0 ;
8337   Dali::Quaternion *arg2 = 0 ;
8338   float result;
8339
8340   arg1 = (Dali::Quaternion *)jarg1;
8341   if (!arg1) {
8342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
8343     return 0;
8344   }
8345   arg2 = (Dali::Quaternion *)jarg2;
8346   if (!arg2) {
8347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
8348     return 0;
8349   }
8350   {
8351     try {
8352       result = (float)Dali::Quaternion::AngleBetween((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
8353     } CALL_CATCH_EXCEPTION(0);
8354   }
8355
8356   jresult = result;
8357   return jresult;
8358 }
8359
8360
8361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_0() {
8362   void * jresult ;
8363   Dali::Matrix *result = 0 ;
8364
8365   {
8366     try {
8367       result = (Dali::Matrix *)new Dali::Matrix();
8368     } CALL_CATCH_EXCEPTION(0);
8369   }
8370
8371   jresult = (void *)result;
8372   return jresult;
8373 }
8374
8375
8376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_1(unsigned int jarg1) {
8377   void * jresult ;
8378   bool arg1 ;
8379   Dali::Matrix *result = 0 ;
8380
8381   arg1 = jarg1 ? true : false;
8382   {
8383     try {
8384       result = (Dali::Matrix *)new Dali::Matrix(arg1);
8385     } CALL_CATCH_EXCEPTION(0);
8386   }
8387
8388   jresult = (void *)result;
8389   return jresult;
8390 }
8391
8392
8393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_2(float* jarg1) {
8394   void * jresult ;
8395   float *arg1 = (float *) 0 ;
8396   Dali::Matrix *result = 0 ;
8397
8398   arg1 = jarg1;
8399   {
8400     try {
8401       result = (Dali::Matrix *)new Dali::Matrix((float const *)arg1);
8402     } CALL_CATCH_EXCEPTION(0);
8403   }
8404
8405   jresult = (void *)result;
8406
8407
8408   return jresult;
8409 }
8410
8411
8412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_3(void * jarg1) {
8413   void * jresult ;
8414   Dali::Quaternion *arg1 = 0 ;
8415   Dali::Matrix *result = 0 ;
8416
8417   arg1 = (Dali::Quaternion *)jarg1;
8418   if (!arg1) {
8419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
8420     return 0;
8421   }
8422   {
8423     try {
8424       result = (Dali::Matrix *)new Dali::Matrix((Dali::Quaternion const &)*arg1);
8425     } CALL_CATCH_EXCEPTION(0);
8426   }
8427
8428   jresult = (void *)result;
8429   return jresult;
8430 }
8431
8432
8433 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_4(void * jarg1) {
8434   void * jresult ;
8435   Dali::Matrix *arg1 = 0 ;
8436   Dali::Matrix *result = 0 ;
8437
8438   arg1 = (Dali::Matrix *)jarg1;
8439   if (!arg1) {
8440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
8441     return 0;
8442   }
8443   {
8444     try {
8445       result = (Dali::Matrix *)new Dali::Matrix((Dali::Matrix const &)*arg1);
8446     } CALL_CATCH_EXCEPTION(0);
8447   }
8448
8449   jresult = (void *)result;
8450   return jresult;
8451 }
8452
8453
8454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Assign(void * jarg1, void * jarg2) {
8455   void * jresult ;
8456   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8457   Dali::Matrix *arg2 = 0 ;
8458   Dali::Matrix *result = 0 ;
8459
8460   arg1 = (Dali::Matrix *)jarg1;
8461   arg2 = (Dali::Matrix *)jarg2;
8462   if (!arg2) {
8463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
8464     return 0;
8465   }
8466   {
8467     try {
8468       result = (Dali::Matrix *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
8469     } CALL_CATCH_EXCEPTION(0);
8470   }
8471
8472   jresult = (void *)result;
8473   return jresult;
8474 }
8475
8476
8477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_IDENTITY_get() {
8478   void * jresult ;
8479   Dali::Matrix *result = 0 ;
8480
8481   result = (Dali::Matrix *)&Dali::Matrix::IDENTITY;
8482   jresult = (void *)result;
8483   return jresult;
8484 }
8485
8486
8487 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentity(void * jarg1) {
8488   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8489
8490   arg1 = (Dali::Matrix *)jarg1;
8491   {
8492     try {
8493       (arg1)->SetIdentity();
8494     } CALL_CATCH_EXCEPTION();
8495   }
8496
8497 }
8498
8499
8500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentityAndScale(void * jarg1, void * jarg2) {
8501   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8502   Dali::Vector3 *arg2 = 0 ;
8503
8504   arg1 = (Dali::Matrix *)jarg1;
8505   arg2 = (Dali::Vector3 *)jarg2;
8506   if (!arg2) {
8507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8508     return ;
8509   }
8510   {
8511     try {
8512       (arg1)->SetIdentityAndScale((Dali::Vector3 const &)*arg2);
8513     } CALL_CATCH_EXCEPTION();
8514   }
8515
8516 }
8517
8518
8519 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_InvertTransform(void * jarg1, void * jarg2) {
8520   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8521   Dali::Matrix *arg2 = 0 ;
8522
8523   arg1 = (Dali::Matrix *)jarg1;
8524   arg2 = (Dali::Matrix *)jarg2;
8525   if (!arg2) {
8526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
8527     return ;
8528   }
8529   {
8530     try {
8531       ((Dali::Matrix const *)arg1)->InvertTransform(*arg2);
8532     } CALL_CATCH_EXCEPTION();
8533   }
8534
8535 }
8536
8537
8538 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_Invert(void * jarg1) {
8539   unsigned int jresult ;
8540   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8541   bool result;
8542
8543   arg1 = (Dali::Matrix *)jarg1;
8544   {
8545     try {
8546       result = (bool)(arg1)->Invert();
8547     } CALL_CATCH_EXCEPTION(0);
8548   }
8549
8550   jresult = result;
8551   return jresult;
8552 }
8553
8554
8555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Transpose(void * jarg1) {
8556   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8557
8558   arg1 = (Dali::Matrix *)jarg1;
8559   {
8560     try {
8561       (arg1)->Transpose();
8562     } CALL_CATCH_EXCEPTION();
8563   }
8564
8565 }
8566
8567
8568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetXAxis(void * jarg1) {
8569   void * jresult ;
8570   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8571   Dali::Vector3 result;
8572
8573   arg1 = (Dali::Matrix *)jarg1;
8574   {
8575     try {
8576       result = ((Dali::Matrix const *)arg1)->GetXAxis();
8577     } CALL_CATCH_EXCEPTION(0);
8578   }
8579
8580   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
8581   return jresult;
8582 }
8583
8584
8585 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetYAxis(void * jarg1) {
8586   void * jresult ;
8587   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8588   Dali::Vector3 result;
8589
8590   arg1 = (Dali::Matrix *)jarg1;
8591   {
8592     try {
8593       result = ((Dali::Matrix const *)arg1)->GetYAxis();
8594     } CALL_CATCH_EXCEPTION(0);
8595   }
8596
8597   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
8598   return jresult;
8599 }
8600
8601
8602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetZAxis(void * jarg1) {
8603   void * jresult ;
8604   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8605   Dali::Vector3 result;
8606
8607   arg1 = (Dali::Matrix *)jarg1;
8608   {
8609     try {
8610       result = ((Dali::Matrix const *)arg1)->GetZAxis();
8611     } CALL_CATCH_EXCEPTION(0);
8612   }
8613
8614   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
8615   return jresult;
8616 }
8617
8618
8619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetXAxis(void * jarg1, void * jarg2) {
8620   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8621   Dali::Vector3 *arg2 = 0 ;
8622
8623   arg1 = (Dali::Matrix *)jarg1;
8624   arg2 = (Dali::Vector3 *)jarg2;
8625   if (!arg2) {
8626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8627     return ;
8628   }
8629   {
8630     try {
8631       (arg1)->SetXAxis((Dali::Vector3 const &)*arg2);
8632     } CALL_CATCH_EXCEPTION();
8633   }
8634
8635 }
8636
8637
8638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetYAxis(void * jarg1, void * jarg2) {
8639   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8640   Dali::Vector3 *arg2 = 0 ;
8641
8642   arg1 = (Dali::Matrix *)jarg1;
8643   arg2 = (Dali::Vector3 *)jarg2;
8644   if (!arg2) {
8645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8646     return ;
8647   }
8648   {
8649     try {
8650       (arg1)->SetYAxis((Dali::Vector3 const &)*arg2);
8651     } CALL_CATCH_EXCEPTION();
8652   }
8653
8654 }
8655
8656
8657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetZAxis(void * jarg1, void * jarg2) {
8658   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8659   Dali::Vector3 *arg2 = 0 ;
8660
8661   arg1 = (Dali::Matrix *)jarg1;
8662   arg2 = (Dali::Vector3 *)jarg2;
8663   if (!arg2) {
8664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8665     return ;
8666   }
8667   {
8668     try {
8669       (arg1)->SetZAxis((Dali::Vector3 const &)*arg2);
8670     } CALL_CATCH_EXCEPTION();
8671   }
8672
8673 }
8674
8675
8676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation(void * jarg1) {
8677   void * jresult ;
8678   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8679   Dali::Vector4 *result = 0 ;
8680
8681   arg1 = (Dali::Matrix *)jarg1;
8682   {
8683     try {
8684       result = (Dali::Vector4 *) &((Dali::Matrix const *)arg1)->GetTranslation();
8685     } CALL_CATCH_EXCEPTION(0);
8686   }
8687
8688   jresult = (void *)result;
8689   return jresult;
8690 }
8691
8692
8693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation3(void * jarg1) {
8694   void * jresult ;
8695   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8696   Dali::Vector3 *result = 0 ;
8697
8698   arg1 = (Dali::Matrix *)jarg1;
8699   {
8700     try {
8701       result = (Dali::Vector3 *) &((Dali::Matrix const *)arg1)->GetTranslation3();
8702     } CALL_CATCH_EXCEPTION(0);
8703   }
8704
8705   jresult = (void *)result;
8706   return jresult;
8707 }
8708
8709
8710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_0(void * jarg1, void * jarg2) {
8711   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8712   Dali::Vector4 *arg2 = 0 ;
8713
8714   arg1 = (Dali::Matrix *)jarg1;
8715   arg2 = (Dali::Vector4 *)jarg2;
8716   if (!arg2) {
8717     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8718     return ;
8719   }
8720   {
8721     try {
8722       (arg1)->SetTranslation((Dali::Vector4 const &)*arg2);
8723     } CALL_CATCH_EXCEPTION();
8724   }
8725
8726 }
8727
8728
8729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_1(void * jarg1, void * jarg2) {
8730   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8731   Dali::Vector3 *arg2 = 0 ;
8732
8733   arg1 = (Dali::Matrix *)jarg1;
8734   arg2 = (Dali::Vector3 *)jarg2;
8735   if (!arg2) {
8736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8737     return ;
8738   }
8739   {
8740     try {
8741       (arg1)->SetTranslation((Dali::Vector3 const &)*arg2);
8742     } CALL_CATCH_EXCEPTION();
8743   }
8744
8745 }
8746
8747
8748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_OrthoNormalize(void * jarg1) {
8749   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8750
8751   arg1 = (Dali::Matrix *)jarg1;
8752   {
8753     try {
8754       (arg1)->OrthoNormalize();
8755     } CALL_CATCH_EXCEPTION();
8756   }
8757
8758 }
8759
8760
8761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_AsFloat__SWIG_0(void * jarg1) {
8762   void * jresult ;
8763   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8764   float *result = 0 ;
8765
8766   arg1 = (Dali::Matrix *)jarg1;
8767   {
8768     try {
8769       result = (float *)((Dali::Matrix const *)arg1)->AsFloat();
8770     } CALL_CATCH_EXCEPTION(0);
8771   }
8772
8773   jresult = (void *)result;
8774   return jresult;
8775 }
8776
8777
8778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
8779   Dali::Matrix *arg1 = 0 ;
8780   Dali::Matrix *arg2 = 0 ;
8781   Dali::Matrix *arg3 = 0 ;
8782
8783   arg1 = (Dali::Matrix *)jarg1;
8784   if (!arg1) {
8785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
8786     return ;
8787   }
8788   arg2 = (Dali::Matrix *)jarg2;
8789   if (!arg2) {
8790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
8791     return ;
8792   }
8793   arg3 = (Dali::Matrix *)jarg3;
8794   if (!arg3) {
8795     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
8796     return ;
8797   }
8798   {
8799     try {
8800       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Matrix const &)*arg3);
8801     } CALL_CATCH_EXCEPTION();
8802   }
8803
8804 }
8805
8806
8807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
8808   Dali::Matrix *arg1 = 0 ;
8809   Dali::Matrix *arg2 = 0 ;
8810   Dali::Quaternion *arg3 = 0 ;
8811
8812   arg1 = (Dali::Matrix *)jarg1;
8813   if (!arg1) {
8814     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
8815     return ;
8816   }
8817   arg2 = (Dali::Matrix *)jarg2;
8818   if (!arg2) {
8819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
8820     return ;
8821   }
8822   arg3 = (Dali::Quaternion *)jarg3;
8823   if (!arg3) {
8824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
8825     return ;
8826   }
8827   {
8828     try {
8829       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Quaternion const &)*arg3);
8830     } CALL_CATCH_EXCEPTION();
8831   }
8832
8833 }
8834
8835
8836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_2(void * jarg1, void * jarg2) {
8837   void * jresult ;
8838   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8839   Dali::Vector4 *arg2 = 0 ;
8840   Dali::Vector4 result;
8841
8842   arg1 = (Dali::Matrix *)jarg1;
8843   arg2 = (Dali::Vector4 *)jarg2;
8844   if (!arg2) {
8845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8846     return 0;
8847   }
8848   {
8849     try {
8850       result = ((Dali::Matrix const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
8851     } CALL_CATCH_EXCEPTION(0);
8852   }
8853
8854   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8855   return jresult;
8856 }
8857
8858
8859 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_EqualTo(void * jarg1, void * jarg2) {
8860   unsigned int jresult ;
8861   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8862   Dali::Matrix *arg2 = 0 ;
8863   bool result;
8864
8865   arg1 = (Dali::Matrix *)jarg1;
8866   arg2 = (Dali::Matrix *)jarg2;
8867   if (!arg2) {
8868     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
8869     return 0;
8870   }
8871   {
8872     try {
8873       result = (bool)((Dali::Matrix const *)arg1)->operator ==((Dali::Matrix const &)*arg2);
8874     } CALL_CATCH_EXCEPTION(0);
8875   }
8876
8877   jresult = result;
8878   return jresult;
8879 }
8880
8881
8882 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_NotEqualTo(void * jarg1, void * jarg2) {
8883   unsigned int jresult ;
8884   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8885   Dali::Matrix *arg2 = 0 ;
8886   bool result;
8887
8888   arg1 = (Dali::Matrix *)jarg1;
8889   arg2 = (Dali::Matrix *)jarg2;
8890   if (!arg2) {
8891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
8892     return 0;
8893   }
8894   {
8895     try {
8896       result = (bool)((Dali::Matrix const *)arg1)->operator !=((Dali::Matrix const &)*arg2);
8897     } CALL_CATCH_EXCEPTION(0);
8898   }
8899
8900   jresult = result;
8901   return jresult;
8902 }
8903
8904
8905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
8906   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8907   Dali::Vector3 *arg2 = 0 ;
8908   Dali::Quaternion *arg3 = 0 ;
8909   Dali::Vector3 *arg4 = 0 ;
8910
8911   arg1 = (Dali::Matrix *)jarg1;
8912   arg2 = (Dali::Vector3 *)jarg2;
8913   if (!arg2) {
8914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8915     return ;
8916   }
8917   arg3 = (Dali::Quaternion *)jarg3;
8918   if (!arg3) {
8919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
8920     return ;
8921   }
8922   arg4 = (Dali::Vector3 *)jarg4;
8923   if (!arg4) {
8924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8925     return ;
8926   }
8927   {
8928     try {
8929       (arg1)->SetTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
8930     } CALL_CATCH_EXCEPTION();
8931   }
8932
8933 }
8934
8935
8936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
8937   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8938   Dali::Vector3 *arg2 = 0 ;
8939   Dali::Quaternion *arg3 = 0 ;
8940   Dali::Vector3 *arg4 = 0 ;
8941
8942   arg1 = (Dali::Matrix *)jarg1;
8943   arg2 = (Dali::Vector3 *)jarg2;
8944   if (!arg2) {
8945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8946     return ;
8947   }
8948   arg3 = (Dali::Quaternion *)jarg3;
8949   if (!arg3) {
8950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
8951     return ;
8952   }
8953   arg4 = (Dali::Vector3 *)jarg4;
8954   if (!arg4) {
8955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8956     return ;
8957   }
8958   {
8959     try {
8960       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
8961     } CALL_CATCH_EXCEPTION();
8962   }
8963
8964 }
8965
8966
8967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
8968   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8969   Dali::Vector3 *arg2 = 0 ;
8970   Dali::Vector3 *arg3 = 0 ;
8971   Dali::Vector3 *arg4 = 0 ;
8972   Dali::Vector3 *arg5 = 0 ;
8973
8974   arg1 = (Dali::Matrix *)jarg1;
8975   arg2 = (Dali::Vector3 *)jarg2;
8976   if (!arg2) {
8977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8978     return ;
8979   }
8980   arg3 = (Dali::Vector3 *)jarg3;
8981   if (!arg3) {
8982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8983     return ;
8984   }
8985   arg4 = (Dali::Vector3 *)jarg4;
8986   if (!arg4) {
8987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8988     return ;
8989   }
8990   arg5 = (Dali::Vector3 *)jarg5;
8991   if (!arg5) {
8992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8993     return ;
8994   }
8995   {
8996     try {
8997       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3,(Dali::Vector3 const &)*arg4,(Dali::Vector3 const &)*arg5);
8998     } CALL_CATCH_EXCEPTION();
8999   }
9000
9001 }
9002
9003
9004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_GetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
9005   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
9006   Dali::Vector3 *arg2 = 0 ;
9007   Dali::Quaternion *arg3 = 0 ;
9008   Dali::Vector3 *arg4 = 0 ;
9009
9010   arg1 = (Dali::Matrix *)jarg1;
9011   arg2 = (Dali::Vector3 *)jarg2;
9012   if (!arg2) {
9013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
9014     return ;
9015   }
9016   arg3 = (Dali::Quaternion *)jarg3;
9017   if (!arg3) {
9018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
9019     return ;
9020   }
9021   arg4 = (Dali::Vector3 *)jarg4;
9022   if (!arg4) {
9023     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
9024     return ;
9025   }
9026   {
9027     try {
9028       ((Dali::Matrix const *)arg1)->GetTransformComponents(*arg2,*arg3,*arg4);
9029     } CALL_CATCH_EXCEPTION();
9030   }
9031
9032 }
9033
9034
9035 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix(void * jarg1) {
9036   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
9037
9038   arg1 = (Dali::Matrix *)jarg1;
9039   {
9040     try {
9041       delete arg1;
9042     } CALL_CATCH_EXCEPTION();
9043   }
9044
9045 }
9046
9047
9048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_IDENTITY_get() {
9049   void * jresult ;
9050   Dali::Matrix3 *result = 0 ;
9051
9052   result = (Dali::Matrix3 *)&Dali::Matrix3::IDENTITY;
9053   jresult = (void *)result;
9054   return jresult;
9055 }
9056
9057
9058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_0() {
9059   void * jresult ;
9060   Dali::Matrix3 *result = 0 ;
9061
9062   {
9063     try {
9064       result = (Dali::Matrix3 *)new Dali::Matrix3();
9065     } CALL_CATCH_EXCEPTION(0);
9066   }
9067
9068   jresult = (void *)result;
9069   return jresult;
9070 }
9071
9072
9073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_1(void * jarg1) {
9074   void * jresult ;
9075   Dali::Matrix3 *arg1 = 0 ;
9076   Dali::Matrix3 *result = 0 ;
9077
9078   arg1 = (Dali::Matrix3 *)jarg1;
9079   if (!arg1) {
9080     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
9081     return 0;
9082   }
9083   {
9084     try {
9085       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix3 const &)*arg1);
9086     } CALL_CATCH_EXCEPTION(0);
9087   }
9088
9089   jresult = (void *)result;
9090   return jresult;
9091 }
9092
9093
9094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_2(void * jarg1) {
9095   void * jresult ;
9096   Dali::Matrix *arg1 = 0 ;
9097   Dali::Matrix3 *result = 0 ;
9098
9099   arg1 = (Dali::Matrix *)jarg1;
9100   if (!arg1) {
9101     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
9102     return 0;
9103   }
9104   {
9105     try {
9106       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix const &)*arg1);
9107     } CALL_CATCH_EXCEPTION(0);
9108   }
9109
9110   jresult = (void *)result;
9111   return jresult;
9112 }
9113
9114
9115 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) {
9116   void * jresult ;
9117   float arg1 ;
9118   float arg2 ;
9119   float arg3 ;
9120   float arg4 ;
9121   float arg5 ;
9122   float arg6 ;
9123   float arg7 ;
9124   float arg8 ;
9125   float arg9 ;
9126   Dali::Matrix3 *result = 0 ;
9127
9128   arg1 = (float)jarg1;
9129   arg2 = (float)jarg2;
9130   arg3 = (float)jarg3;
9131   arg4 = (float)jarg4;
9132   arg5 = (float)jarg5;
9133   arg6 = (float)jarg6;
9134   arg7 = (float)jarg7;
9135   arg8 = (float)jarg8;
9136   arg9 = (float)jarg9;
9137   {
9138     try {
9139       result = (Dali::Matrix3 *)new Dali::Matrix3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
9140     } CALL_CATCH_EXCEPTION(0);
9141   }
9142
9143   jresult = (void *)result;
9144   return jresult;
9145 }
9146
9147
9148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_0(void * jarg1, void * jarg2) {
9149   void * jresult ;
9150   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
9151   Dali::Matrix3 *arg2 = 0 ;
9152   Dali::Matrix3 *result = 0 ;
9153
9154   arg1 = (Dali::Matrix3 *)jarg1;
9155   arg2 = (Dali::Matrix3 *)jarg2;
9156   if (!arg2) {
9157     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
9158     return 0;
9159   }
9160   {
9161     try {
9162       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix3 const &)*arg2);
9163     } CALL_CATCH_EXCEPTION(0);
9164   }
9165
9166   jresult = (void *)result;
9167   return jresult;
9168 }
9169
9170
9171 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_1(void * jarg1, void * jarg2) {
9172   void * jresult ;
9173   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
9174   Dali::Matrix *arg2 = 0 ;
9175   Dali::Matrix3 *result = 0 ;
9176
9177   arg1 = (Dali::Matrix3 *)jarg1;
9178   arg2 = (Dali::Matrix *)jarg2;
9179   if (!arg2) {
9180     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
9181     return 0;
9182   }
9183   {
9184     try {
9185       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
9186     } CALL_CATCH_EXCEPTION(0);
9187   }
9188
9189   jresult = (void *)result;
9190   return jresult;
9191 }
9192
9193
9194 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_EqualTo(void * jarg1, void * jarg2) {
9195   unsigned int jresult ;
9196   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
9197   Dali::Matrix3 *arg2 = 0 ;
9198   bool result;
9199
9200   arg1 = (Dali::Matrix3 *)jarg1;
9201   arg2 = (Dali::Matrix3 *)jarg2;
9202   if (!arg2) {
9203     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
9204     return 0;
9205   }
9206   {
9207     try {
9208       result = (bool)((Dali::Matrix3 const *)arg1)->operator ==((Dali::Matrix3 const &)*arg2);
9209     } CALL_CATCH_EXCEPTION(0);
9210   }
9211
9212   jresult = result;
9213   return jresult;
9214 }
9215
9216
9217 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_NotEqualTo(void * jarg1, void * jarg2) {
9218   unsigned int jresult ;
9219   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
9220   Dali::Matrix3 *arg2 = 0 ;
9221   bool result;
9222
9223   arg1 = (Dali::Matrix3 *)jarg1;
9224   arg2 = (Dali::Matrix3 *)jarg2;
9225   if (!arg2) {
9226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
9227     return 0;
9228   }
9229   {
9230     try {
9231       result = (bool)((Dali::Matrix3 const *)arg1)->operator !=((Dali::Matrix3 const &)*arg2);
9232     } CALL_CATCH_EXCEPTION(0);
9233   }
9234
9235   jresult = result;
9236   return jresult;
9237 }
9238
9239
9240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix3(void * jarg1) {
9241   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
9242
9243   arg1 = (Dali::Matrix3 *)jarg1;
9244   {
9245     try {
9246       delete arg1;
9247     } CALL_CATCH_EXCEPTION();
9248   }
9249
9250 }
9251
9252
9253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetIdentity(void * jarg1) {
9254   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
9255
9256   arg1 = (Dali::Matrix3 *)jarg1;
9257   {
9258     try {
9259       (arg1)->SetIdentity();
9260     } CALL_CATCH_EXCEPTION();
9261   }
9262
9263 }
9264
9265
9266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_AsFloat__SWIG_0(void * jarg1) {
9267   void * jresult ;
9268   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
9269   float *result = 0 ;
9270
9271   arg1 = (Dali::Matrix3 *)jarg1;
9272   {
9273     try {
9274       result = (float *)((Dali::Matrix3 const *)arg1)->AsFloat();
9275     } CALL_CATCH_EXCEPTION(0);
9276   }
9277
9278   jresult = (void *)result;
9279   return jresult;
9280 }
9281
9282
9283 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Invert(void * jarg1) {
9284   unsigned int jresult ;
9285   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
9286   bool result;
9287
9288   arg1 = (Dali::Matrix3 *)jarg1;
9289   {
9290     try {
9291       result = (bool)(arg1)->Invert();
9292     } CALL_CATCH_EXCEPTION(0);
9293   }
9294
9295   jresult = result;
9296   return jresult;
9297 }
9298
9299
9300 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Transpose(void * jarg1) {
9301   unsigned int jresult ;
9302   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
9303   bool result;
9304
9305   arg1 = (Dali::Matrix3 *)jarg1;
9306   {
9307     try {
9308       result = (bool)(arg1)->Transpose();
9309     } CALL_CATCH_EXCEPTION(0);
9310   }
9311
9312   jresult = result;
9313   return jresult;
9314 }
9315
9316
9317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Scale(void * jarg1, float jarg2) {
9318   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
9319   float arg2 ;
9320
9321   arg1 = (Dali::Matrix3 *)jarg1;
9322   arg2 = (float)jarg2;
9323   {
9324     try {
9325       (arg1)->Scale(arg2);
9326     } CALL_CATCH_EXCEPTION();
9327   }
9328
9329 }
9330
9331
9332 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_Magnitude(void * jarg1) {
9333   float jresult ;
9334   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
9335   float result;
9336
9337   arg1 = (Dali::Matrix3 *)jarg1;
9338   {
9339     try {
9340       result = (float)((Dali::Matrix3 const *)arg1)->Magnitude();
9341     } CALL_CATCH_EXCEPTION(0);
9342   }
9343
9344   jresult = result;
9345   return jresult;
9346 }
9347
9348
9349 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_ScaledInverseTranspose(void * jarg1) {
9350   unsigned int jresult ;
9351   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
9352   bool result;
9353
9354   arg1 = (Dali::Matrix3 *)jarg1;
9355   {
9356     try {
9357       result = (bool)(arg1)->ScaledInverseTranspose();
9358     } CALL_CATCH_EXCEPTION(0);
9359   }
9360
9361   jresult = result;
9362   return jresult;
9363 }
9364
9365
9366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Multiply(void * jarg1, void * jarg2, void * jarg3) {
9367   Dali::Matrix3 *arg1 = 0 ;
9368   Dali::Matrix3 *arg2 = 0 ;
9369   Dali::Matrix3 *arg3 = 0 ;
9370
9371   arg1 = (Dali::Matrix3 *)jarg1;
9372   if (!arg1) {
9373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
9374     return ;
9375   }
9376   arg2 = (Dali::Matrix3 *)jarg2;
9377   if (!arg2) {
9378     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
9379     return ;
9380   }
9381   arg3 = (Dali::Matrix3 *)jarg3;
9382   if (!arg3) {
9383     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
9384     return ;
9385   }
9386   {
9387     try {
9388       Dali::Matrix3::Multiply(*arg1,(Dali::Matrix3 const &)*arg2,(Dali::Matrix3 const &)*arg3);
9389     } CALL_CATCH_EXCEPTION();
9390   }
9391
9392 }
9393
9394
9395 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Range(float jarg1, float jarg2) {
9396   float jresult ;
9397   float arg1 ;
9398   float arg2 ;
9399   float result;
9400
9401   arg1 = (float)jarg1;
9402   arg2 = (float)jarg2;
9403   {
9404     try {
9405       result = (float)Dali::Random::Range(arg1,arg2);
9406     } CALL_CATCH_EXCEPTION(0);
9407   }
9408
9409   jresult = result;
9410   return jresult;
9411 }
9412
9413
9414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Axis() {
9415   void * jresult ;
9416   Dali::Vector4 result;
9417
9418   {
9419     try {
9420       result = Dali::Random::Axis();
9421     } CALL_CATCH_EXCEPTION(0);
9422   }
9423
9424   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
9425   return jresult;
9426 }
9427
9428
9429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_0() {
9430   void * jresult ;
9431   Dali::AngleAxis *result = 0 ;
9432
9433   {
9434     try {
9435       result = (Dali::AngleAxis *)new Dali::AngleAxis();
9436     } CALL_CATCH_EXCEPTION(0);
9437   }
9438
9439   jresult = (void *)result;
9440   return jresult;
9441 }
9442
9443
9444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_1(void * jarg1, void * jarg2) {
9445   void * jresult ;
9446   Dali::Radian arg1 ;
9447   Dali::Vector3 *arg2 = 0 ;
9448   Dali::Radian *argp1 ;
9449   Dali::AngleAxis *result = 0 ;
9450
9451   argp1 = (Dali::Radian *)jarg1;
9452   if (!argp1) {
9453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9454     return 0;
9455   }
9456   arg1 = *argp1;
9457   arg2 = (Dali::Vector3 *)jarg2;
9458   if (!arg2) {
9459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
9460     return 0;
9461   }
9462   {
9463     try {
9464       result = (Dali::AngleAxis *)new Dali::AngleAxis(arg1,(Dali::Vector3 const &)*arg2);
9465     } CALL_CATCH_EXCEPTION(0);
9466   }
9467
9468   jresult = (void *)result;
9469   return jresult;
9470 }
9471
9472
9473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_angle_set(void * jarg1, void * jarg2) {
9474   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
9475   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
9476
9477   arg1 = (Dali::AngleAxis *)jarg1;
9478   arg2 = (Dali::Radian *)jarg2;
9479   if (arg1) (arg1)->angle = *arg2;
9480 }
9481
9482
9483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_angle_get(void * jarg1) {
9484   void * jresult ;
9485   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
9486   Dali::Radian *result = 0 ;
9487
9488   arg1 = (Dali::AngleAxis *)jarg1;
9489   result = (Dali::Radian *)& ((arg1)->angle);
9490   jresult = (void *)result;
9491   return jresult;
9492 }
9493
9494
9495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_axis_set(void * jarg1, void * jarg2) {
9496   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
9497   Dali::Vector3 *arg2 = (Dali::Vector3 *) 0 ;
9498
9499   arg1 = (Dali::AngleAxis *)jarg1;
9500   arg2 = (Dali::Vector3 *)jarg2;
9501   if (arg1) (arg1)->axis = *arg2;
9502 }
9503
9504
9505 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_axis_get(void * jarg1) {
9506   void * jresult ;
9507   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
9508   Dali::Vector3 *result = 0 ;
9509
9510   arg1 = (Dali::AngleAxis *)jarg1;
9511   result = (Dali::Vector3 *)& ((arg1)->axis);
9512   jresult = (void *)result;
9513   return jresult;
9514 }
9515
9516
9517 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleAxis(void * jarg1) {
9518   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
9519
9520   arg1 = (Dali::AngleAxis *)jarg1;
9521   {
9522     try {
9523       delete arg1;
9524     } CALL_CATCH_EXCEPTION();
9525   }
9526
9527 }
9528
9529
9530 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_9(void * jarg1, void * jarg2) {
9531   unsigned int jresult ;
9532   Dali::AngleAxis *arg1 = 0 ;
9533   Dali::AngleAxis *arg2 = 0 ;
9534   bool result;
9535
9536   arg1 = (Dali::AngleAxis *)jarg1;
9537   if (!arg1) {
9538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
9539     return 0;
9540   }
9541   arg2 = (Dali::AngleAxis *)jarg2;
9542   if (!arg2) {
9543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
9544     return 0;
9545   }
9546   {
9547     try {
9548       result = (bool)Dali::operator ==((Dali::AngleAxis const &)*arg1,(Dali::AngleAxis const &)*arg2);
9549     } CALL_CATCH_EXCEPTION(0);
9550   }
9551
9552   jresult = result;
9553   return jresult;
9554 }
9555
9556
9557 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NextPowerOfTwo(unsigned int jarg1) {
9558   unsigned int jresult ;
9559   unsigned int arg1 ;
9560   unsigned int result;
9561
9562   arg1 = (unsigned int)jarg1;
9563   {
9564     try {
9565       result = (unsigned int)Dali::NextPowerOfTwo(arg1);
9566     } CALL_CATCH_EXCEPTION(0);
9567   }
9568
9569   jresult = result;
9570   return jresult;
9571 }
9572
9573
9574 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsPowerOfTwo(unsigned int jarg1) {
9575   unsigned int jresult ;
9576   unsigned int arg1 ;
9577   bool result;
9578
9579   arg1 = (unsigned int)jarg1;
9580   {
9581     try {
9582       result = (bool)Dali::IsPowerOfTwo(arg1);
9583     } CALL_CATCH_EXCEPTION(0);
9584   }
9585
9586   jresult = result;
9587   return jresult;
9588 }
9589
9590
9591 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GetRangedEpsilon(float jarg1, float jarg2) {
9592   float jresult ;
9593   float arg1 ;
9594   float arg2 ;
9595   float result;
9596
9597   arg1 = (float)jarg1;
9598   arg2 = (float)jarg2;
9599   {
9600     try {
9601       result = (float)Dali::GetRangedEpsilon(arg1,arg2);
9602     } CALL_CATCH_EXCEPTION(0);
9603   }
9604
9605   jresult = result;
9606   return jresult;
9607 }
9608
9609
9610 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualsZero(float jarg1) {
9611   unsigned int jresult ;
9612   float arg1 ;
9613   bool result;
9614
9615   arg1 = (float)jarg1;
9616   {
9617     try {
9618       result = (bool)Dali::EqualsZero(arg1);
9619     } CALL_CATCH_EXCEPTION(0);
9620   }
9621
9622   jresult = result;
9623   return jresult;
9624 }
9625
9626
9627 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_0(float jarg1, float jarg2) {
9628   unsigned int jresult ;
9629   float arg1 ;
9630   float arg2 ;
9631   bool result;
9632
9633   arg1 = (float)jarg1;
9634   arg2 = (float)jarg2;
9635   {
9636     try {
9637       result = (bool)Dali::Equals(arg1,arg2);
9638     } CALL_CATCH_EXCEPTION(0);
9639   }
9640
9641   jresult = result;
9642   return jresult;
9643 }
9644
9645
9646 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_1(float jarg1, float jarg2, float jarg3) {
9647   unsigned int jresult ;
9648   float arg1 ;
9649   float arg2 ;
9650   float arg3 ;
9651   bool result;
9652
9653   arg1 = (float)jarg1;
9654   arg2 = (float)jarg2;
9655   arg3 = (float)jarg3;
9656   {
9657     try {
9658       result = (bool)Dali::Equals(arg1,arg2,arg3);
9659     } CALL_CATCH_EXCEPTION(0);
9660   }
9661
9662   jresult = result;
9663   return jresult;
9664 }
9665
9666
9667 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Round(float jarg1, int jarg2) {
9668   float jresult ;
9669   float arg1 ;
9670   int arg2 ;
9671   float result;
9672
9673   arg1 = (float)jarg1;
9674   arg2 = (int)jarg2;
9675   {
9676     try {
9677       result = (float)Dali::Round(arg1,arg2);
9678     } CALL_CATCH_EXCEPTION(0);
9679   }
9680
9681   jresult = result;
9682   return jresult;
9683 }
9684
9685
9686 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_WrapInDomain(float jarg1, float jarg2, float jarg3) {
9687   float jresult ;
9688   float arg1 ;
9689   float arg2 ;
9690   float arg3 ;
9691   float result;
9692
9693   arg1 = (float)jarg1;
9694   arg2 = (float)jarg2;
9695   arg3 = (float)jarg3;
9696   {
9697     try {
9698       result = (float)Dali::WrapInDomain(arg1,arg2,arg3);
9699     } CALL_CATCH_EXCEPTION(0);
9700   }
9701
9702   jresult = result;
9703   return jresult;
9704 }
9705
9706
9707 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ShortestDistanceInDomain(float jarg1, float jarg2, float jarg3, float jarg4) {
9708   float jresult ;
9709   float arg1 ;
9710   float arg2 ;
9711   float arg3 ;
9712   float arg4 ;
9713   float result;
9714
9715   arg1 = (float)jarg1;
9716   arg2 = (float)jarg2;
9717   arg3 = (float)jarg3;
9718   arg4 = (float)jarg4;
9719   {
9720     try {
9721       result = (float)Dali::ShortestDistanceInDomain(arg1,arg2,arg3,arg4);
9722     } CALL_CATCH_EXCEPTION(0);
9723   }
9724
9725   jresult = result;
9726   return jresult;
9727 }
9728
9729
9730 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_INDEX_get() {
9731   int jresult ;
9732   int result;
9733
9734   result = (int)(int)Dali::Property::INVALID_INDEX;
9735   jresult = result;
9736   return jresult;
9737 }
9738
9739
9740 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_KEY_get() {
9741   int jresult ;
9742   int result;
9743
9744   result = (int)(int)Dali::Property::INVALID_KEY;
9745   jresult = result;
9746   return jresult;
9747 }
9748
9749
9750 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_COMPONENT_INDEX_get() {
9751   int jresult ;
9752   int result;
9753
9754   result = (int)(int)Dali::Property::INVALID_COMPONENT_INDEX;
9755   jresult = result;
9756   return jresult;
9757 }
9758
9759
9760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_0(void * jarg1, int jarg2) {
9761   void * jresult ;
9762   Dali::Handle *arg1 = 0 ;
9763   Dali::Property::Index arg2 ;
9764   Dali::Property *result = 0 ;
9765
9766   arg1 = (Dali::Handle *)jarg1;
9767   if (!arg1) {
9768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
9769     return 0;
9770   }
9771   arg2 = (Dali::Property::Index)jarg2;
9772   {
9773     try {
9774       result = (Dali::Property *)new Dali::Property(*arg1,arg2);
9775     } CALL_CATCH_EXCEPTION(0);
9776   }
9777
9778   jresult = (void *)result;
9779   return jresult;
9780 }
9781
9782
9783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_1(void * jarg1, int jarg2, int jarg3) {
9784   void * jresult ;
9785   Dali::Handle *arg1 = 0 ;
9786   Dali::Property::Index arg2 ;
9787   int arg3 ;
9788   Dali::Property *result = 0 ;
9789
9790   arg1 = (Dali::Handle *)jarg1;
9791   if (!arg1) {
9792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
9793     return 0;
9794   }
9795   arg2 = (Dali::Property::Index)jarg2;
9796   arg3 = (int)jarg3;
9797   {
9798     try {
9799       result = (Dali::Property *)new Dali::Property(*arg1,arg2,arg3);
9800     } CALL_CATCH_EXCEPTION(0);
9801   }
9802
9803   jresult = (void *)result;
9804   return jresult;
9805 }
9806
9807
9808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_2(void * jarg1, char * jarg2) {
9809   void * jresult ;
9810   Dali::Handle *arg1 = 0 ;
9811   std::string *arg2 = 0 ;
9812   Dali::Property *result = 0 ;
9813
9814   arg1 = (Dali::Handle *)jarg1;
9815   if (!arg1) {
9816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
9817     return 0;
9818   }
9819   if (!jarg2) {
9820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
9821     return 0;
9822   }
9823   std::string arg2_str(jarg2);
9824   arg2 = &arg2_str;
9825   {
9826     try {
9827       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2);
9828     } CALL_CATCH_EXCEPTION(0);
9829   }
9830
9831   jresult = (void *)result;
9832
9833   //argout typemap for const std::string&
9834
9835   return jresult;
9836 }
9837
9838
9839 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_3(void * jarg1, char * jarg2, int jarg3) {
9840   void * jresult ;
9841   Dali::Handle *arg1 = 0 ;
9842   std::string *arg2 = 0 ;
9843   int arg3 ;
9844   Dali::Property *result = 0 ;
9845
9846   arg1 = (Dali::Handle *)jarg1;
9847   if (!arg1) {
9848     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
9849     return 0;
9850   }
9851   if (!jarg2) {
9852     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
9853     return 0;
9854   }
9855   std::string arg2_str(jarg2);
9856   arg2 = &arg2_str;
9857   arg3 = (int)jarg3;
9858   {
9859     try {
9860       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2,arg3);
9861     } CALL_CATCH_EXCEPTION(0);
9862   }
9863
9864   jresult = (void *)result;
9865
9866   //argout typemap for const std::string&
9867
9868   return jresult;
9869 }
9870
9871
9872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property(void * jarg1) {
9873   Dali::Property *arg1 = (Dali::Property *) 0 ;
9874
9875   arg1 = (Dali::Property *)jarg1;
9876   {
9877     try {
9878       delete arg1;
9879     } CALL_CATCH_EXCEPTION();
9880   }
9881
9882 }
9883
9884
9885 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property__object_set(void * jarg1, void * jarg2) {
9886   Dali::Property *arg1 = (Dali::Property *) 0 ;
9887   Dali::Handle *arg2 = 0 ;
9888
9889   arg1 = (Dali::Property *)jarg1;
9890   arg2 = (Dali::Handle *)jarg2;
9891   if (!arg2) {
9892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
9893     return ;
9894   }
9895   if (arg1) (arg1)->object = *arg2;
9896 }
9897
9898
9899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property__object_get(void * jarg1) {
9900   void * jresult ;
9901   Dali::Property *arg1 = (Dali::Property *) 0 ;
9902   Dali::Handle *result = 0 ;
9903
9904   arg1 = (Dali::Property *)jarg1;
9905   result = (Dali::Handle *) &(Dali::Handle &) ((arg1)->object);
9906   jresult = (void *)result;
9907   return jresult;
9908 }
9909
9910
9911 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_propertyIndex_set(void * jarg1, int jarg2) {
9912   Dali::Property *arg1 = (Dali::Property *) 0 ;
9913   Dali::Property::Index arg2 ;
9914
9915   arg1 = (Dali::Property *)jarg1;
9916   arg2 = (Dali::Property::Index)jarg2;
9917   if (arg1) (arg1)->propertyIndex = arg2;
9918 }
9919
9920
9921 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_propertyIndex_get(void * jarg1) {
9922   int jresult ;
9923   Dali::Property *arg1 = (Dali::Property *) 0 ;
9924   Dali::Property::Index result;
9925
9926   arg1 = (Dali::Property *)jarg1;
9927   result = (Dali::Property::Index) ((arg1)->propertyIndex);
9928   jresult = result;
9929   return jresult;
9930 }
9931
9932
9933 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_componentIndex_set(void * jarg1, int jarg2) {
9934   Dali::Property *arg1 = (Dali::Property *) 0 ;
9935   int arg2 ;
9936
9937   arg1 = (Dali::Property *)jarg1;
9938   arg2 = (int)jarg2;
9939   if (arg1) (arg1)->componentIndex = arg2;
9940 }
9941
9942
9943 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_componentIndex_get(void * jarg1) {
9944   int jresult ;
9945   Dali::Property *arg1 = (Dali::Property *) 0 ;
9946   int result;
9947
9948   arg1 = (Dali::Property *)jarg1;
9949   result = (int) ((arg1)->componentIndex);
9950   jresult = result;
9951   return jresult;
9952 }
9953
9954
9955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_0() {
9956   void * jresult ;
9957   Dali::Property::Array *result = 0 ;
9958
9959   {
9960     try {
9961       result = (Dali::Property::Array *)new Dali::Property::Array();
9962     } CALL_CATCH_EXCEPTION(0);
9963   }
9964
9965   jresult = (void *)result;
9966   return jresult;
9967 }
9968
9969
9970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_1(void * jarg1) {
9971   void * jresult ;
9972   Dali::Property::Array *arg1 = 0 ;
9973   Dali::Property::Array *result = 0 ;
9974
9975   arg1 = (Dali::Property::Array *)jarg1;
9976   if (!arg1) {
9977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
9978     return 0;
9979   }
9980   {
9981     try {
9982       result = (Dali::Property::Array *)new Dali::Property::Array((Dali::Property::Array const &)*arg1);
9983     } CALL_CATCH_EXCEPTION(0);
9984   }
9985
9986   jresult = (void *)result;
9987   return jresult;
9988 }
9989
9990
9991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Array(void * jarg1) {
9992   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
9993
9994   arg1 = (Dali::Property::Array *)jarg1;
9995   {
9996     try {
9997       delete arg1;
9998     } CALL_CATCH_EXCEPTION();
9999   }
10000
10001 }
10002
10003
10004 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Size(void * jarg1) {
10005   unsigned long jresult ;
10006   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
10007   Dali::Property::Array::SizeType result;
10008
10009   arg1 = (Dali::Property::Array *)jarg1;
10010   {
10011     try {
10012       result = ((Dali::Property::Array const *)arg1)->Size();
10013     } CALL_CATCH_EXCEPTION(0);
10014   }
10015
10016   jresult = (unsigned long)result;
10017   return jresult;
10018 }
10019
10020
10021 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Count(void * jarg1) {
10022   unsigned long jresult ;
10023   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
10024   Dali::Property::Array::SizeType result;
10025
10026   arg1 = (Dali::Property::Array *)jarg1;
10027   {
10028     try {
10029       result = ((Dali::Property::Array const *)arg1)->Count();
10030     } CALL_CATCH_EXCEPTION(0);
10031   }
10032
10033   jresult = (unsigned long)result;
10034   return jresult;
10035 }
10036
10037
10038 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Array_Empty(void * jarg1) {
10039   unsigned int jresult ;
10040   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
10041   bool result;
10042
10043   arg1 = (Dali::Property::Array *)jarg1;
10044   {
10045     try {
10046       result = (bool)((Dali::Property::Array const *)arg1)->Empty();
10047     } CALL_CATCH_EXCEPTION(0);
10048   }
10049
10050   jresult = result;
10051   return jresult;
10052 }
10053
10054
10055 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Clear(void * jarg1) {
10056   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
10057
10058   arg1 = (Dali::Property::Array *)jarg1;
10059   {
10060     try {
10061       (arg1)->Clear();
10062     } CALL_CATCH_EXCEPTION();
10063   }
10064
10065 }
10066
10067
10068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Reserve(void * jarg1, unsigned long jarg2) {
10069   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
10070   Dali::Property::Array::SizeType arg2 ;
10071
10072   arg1 = (Dali::Property::Array *)jarg1;
10073   arg2 = (Dali::Property::Array::SizeType)jarg2;
10074   {
10075     try {
10076       (arg1)->Reserve(arg2);
10077     } CALL_CATCH_EXCEPTION();
10078   }
10079
10080 }
10081
10082
10083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Resize(void * jarg1, unsigned long jarg2) {
10084   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
10085   Dali::Property::Array::SizeType arg2 ;
10086
10087   arg1 = (Dali::Property::Array *)jarg1;
10088   arg2 = (Dali::Property::Array::SizeType)jarg2;
10089   {
10090     try {
10091       (arg1)->Resize(arg2);
10092     } CALL_CATCH_EXCEPTION();
10093   }
10094
10095 }
10096
10097
10098 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Capacity(void * jarg1) {
10099   unsigned long jresult ;
10100   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
10101   Dali::Property::Array::SizeType result;
10102
10103   arg1 = (Dali::Property::Array *)jarg1;
10104   {
10105     try {
10106       result = (arg1)->Capacity();
10107     } CALL_CATCH_EXCEPTION(0);
10108   }
10109
10110   jresult = (unsigned long)result;
10111   return jresult;
10112 }
10113
10114
10115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_PushBack(void * jarg1, void * jarg2) {
10116   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
10117   Dali::Property::Value *arg2 = 0 ;
10118
10119   arg1 = (Dali::Property::Array *)jarg1;
10120   arg2 = (Dali::Property::Value *)jarg2;
10121   if (!arg2) {
10122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
10123     return ;
10124   }
10125   {
10126     try {
10127       (arg1)->PushBack((Dali::Property::Value const &)*arg2);
10128     } CALL_CATCH_EXCEPTION();
10129   }
10130
10131 }
10132
10133
10134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Add(void * jarg1, void * jarg2) {
10135   void * jresult ;
10136   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
10137   Dali::Property::Value *arg2 = 0 ;
10138   Dali::Property::Array *result = 0 ;
10139
10140   arg1 = (Dali::Property::Array *)jarg1;
10141   arg2 = (Dali::Property::Value *)jarg2;
10142   if (!arg2) {
10143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
10144     return 0;
10145   }
10146   {
10147     try {
10148       result = (Dali::Property::Array *) &(arg1)->Add((Dali::Property::Value const &)*arg2);
10149     } CALL_CATCH_EXCEPTION(0);
10150   }
10151
10152   jresult = (void *)result;
10153   return jresult;
10154 }
10155
10156
10157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_GetElementAt__SWIG_0(void * jarg1, unsigned long jarg2) {
10158   void * jresult ;
10159   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
10160   Dali::Property::Array::SizeType arg2 ;
10161   Dali::Property::Value *result = 0 ;
10162
10163   arg1 = (Dali::Property::Array *)jarg1;
10164   arg2 = (Dali::Property::Array::SizeType)jarg2;
10165   {
10166     try {
10167       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->GetElementAt(arg2);
10168     } CALL_CATCH_EXCEPTION(0);
10169   }
10170
10171   jresult = (void *)result;
10172   return jresult;
10173 }
10174
10175
10176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
10177   void * jresult ;
10178   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
10179   Dali::Property::Array::SizeType arg2 ;
10180   Dali::Property::Value *result = 0 ;
10181
10182   arg1 = (Dali::Property::Array *)jarg1;
10183   arg2 = (Dali::Property::Array::SizeType)jarg2;
10184   {
10185     try {
10186       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->operator [](arg2);
10187     } CALL_CATCH_EXCEPTION(0);
10188   }
10189
10190   jresult = (void *)result;
10191   return jresult;
10192 }
10193
10194
10195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Assign(void * jarg1, void * jarg2) {
10196   void * jresult ;
10197   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
10198   Dali::Property::Array *arg2 = 0 ;
10199   Dali::Property::Array *result = 0 ;
10200
10201   arg1 = (Dali::Property::Array *)jarg1;
10202   arg2 = (Dali::Property::Array *)jarg2;
10203   if (!arg2) {
10204     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
10205     return 0;
10206   }
10207   {
10208     try {
10209       result = (Dali::Property::Array *) &(arg1)->operator =((Dali::Property::Array const &)*arg2);
10210     } CALL_CATCH_EXCEPTION(0);
10211   }
10212
10213   jresult = (void *)result;
10214   return jresult;
10215 }
10216
10217
10218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_type_set(void * jarg1, int jarg2) {
10219   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
10220   enum Dali::Property::Key::Type arg2 ;
10221
10222   arg1 = (Dali::Property::Key *)jarg1;
10223   arg2 = (enum Dali::Property::Key::Type)jarg2;
10224   if (arg1) (arg1)->type = arg2;
10225 }
10226
10227
10228 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_type_get(void * jarg1) {
10229   int jresult ;
10230   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
10231   enum Dali::Property::Key::Type result;
10232
10233   arg1 = (Dali::Property::Key *)jarg1;
10234   result = (enum Dali::Property::Key::Type) ((arg1)->type);
10235   jresult = (int)result;
10236   return jresult;
10237 }
10238
10239
10240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_set(void * jarg1, int jarg2) {
10241   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
10242   Dali::Property::Index arg2 ;
10243
10244   arg1 = (Dali::Property::Key *)jarg1;
10245   arg2 = (Dali::Property::Index)jarg2;
10246   if (arg1) (arg1)->indexKey = arg2;
10247 }
10248
10249
10250 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_get(void * jarg1) {
10251   int jresult ;
10252   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
10253   Dali::Property::Index result;
10254
10255   arg1 = (Dali::Property::Key *)jarg1;
10256   result = (Dali::Property::Index) ((arg1)->indexKey);
10257   jresult = result;
10258   return jresult;
10259 }
10260
10261
10262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_set(void * jarg1, char * jarg2) {
10263   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
10264   std::string *arg2 = 0 ;
10265
10266   arg1 = (Dali::Property::Key *)jarg1;
10267   if (!jarg2) {
10268     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10269     return ;
10270   }
10271   std::string arg2_str(jarg2);
10272   arg2 = &arg2_str;
10273   if (arg1) (arg1)->stringKey = *arg2;
10274
10275   //argout typemap for const std::string&
10276
10277 }
10278
10279
10280 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_get(void * jarg1) {
10281   char * jresult ;
10282   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
10283   std::string *result = 0 ;
10284
10285   arg1 = (Dali::Property::Key *)jarg1;
10286   result = (std::string *) & ((arg1)->stringKey);
10287   jresult = SWIG_csharp_string_callback(result->c_str());
10288   return jresult;
10289 }
10290
10291
10292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_0(char * jarg1) {
10293   void * jresult ;
10294   std::string *arg1 = 0 ;
10295   Dali::Property::Key *result = 0 ;
10296
10297   if (!jarg1) {
10298     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10299     return 0;
10300   }
10301   std::string arg1_str(jarg1);
10302   arg1 = &arg1_str;
10303   {
10304     try {
10305       result = (Dali::Property::Key *)new Dali::Property::Key((std::string const &)*arg1);
10306     } CALL_CATCH_EXCEPTION(0);
10307   }
10308
10309   jresult = (void *)result;
10310
10311   //argout typemap for const std::string&
10312
10313   return jresult;
10314 }
10315
10316
10317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_1(int jarg1) {
10318   void * jresult ;
10319   Dali::Property::Index arg1 ;
10320   Dali::Property::Key *result = 0 ;
10321
10322   arg1 = (Dali::Property::Index)jarg1;
10323   {
10324     try {
10325       result = (Dali::Property::Key *)new Dali::Property::Key(arg1);
10326     } CALL_CATCH_EXCEPTION(0);
10327   }
10328
10329   jresult = (void *)result;
10330   return jresult;
10331 }
10332
10333
10334 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_0(void * jarg1, char * jarg2) {
10335   unsigned int jresult ;
10336   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
10337   std::string *arg2 = 0 ;
10338   bool result;
10339
10340   arg1 = (Dali::Property::Key *)jarg1;
10341   if (!jarg2) {
10342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10343     return 0;
10344   }
10345   std::string arg2_str(jarg2);
10346   arg2 = &arg2_str;
10347   {
10348     try {
10349       result = (bool)(arg1)->operator ==((std::string const &)*arg2);
10350     } CALL_CATCH_EXCEPTION(0);
10351   }
10352
10353   jresult = result;
10354
10355   //argout typemap for const std::string&
10356
10357   return jresult;
10358 }
10359
10360
10361 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_1(void * jarg1, int jarg2) {
10362   unsigned int jresult ;
10363   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
10364   Dali::Property::Index arg2 ;
10365   bool result;
10366
10367   arg1 = (Dali::Property::Key *)jarg1;
10368   arg2 = (Dali::Property::Index)jarg2;
10369   {
10370     try {
10371       result = (bool)(arg1)->operator ==(arg2);
10372     } CALL_CATCH_EXCEPTION(0);
10373   }
10374
10375   jresult = result;
10376   return jresult;
10377 }
10378
10379
10380 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_2(void * jarg1, void * jarg2) {
10381   unsigned int jresult ;
10382   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
10383   Dali::Property::Key *arg2 = 0 ;
10384   bool result;
10385
10386   arg1 = (Dali::Property::Key *)jarg1;
10387   arg2 = (Dali::Property::Key *)jarg2;
10388   if (!arg2) {
10389     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
10390     return 0;
10391   }
10392   {
10393     try {
10394       result = (bool)(arg1)->operator ==((Dali::Property::Key const &)*arg2);
10395     } CALL_CATCH_EXCEPTION(0);
10396   }
10397
10398   jresult = result;
10399   return jresult;
10400 }
10401
10402
10403 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_0(void * jarg1, char * jarg2) {
10404   unsigned int jresult ;
10405   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
10406   std::string *arg2 = 0 ;
10407   bool result;
10408
10409   arg1 = (Dali::Property::Key *)jarg1;
10410   if (!jarg2) {
10411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10412     return 0;
10413   }
10414   std::string arg2_str(jarg2);
10415   arg2 = &arg2_str;
10416   {
10417     try {
10418       result = (bool)(arg1)->operator !=((std::string const &)*arg2);
10419     } CALL_CATCH_EXCEPTION(0);
10420   }
10421
10422   jresult = result;
10423
10424   //argout typemap for const std::string&
10425
10426   return jresult;
10427 }
10428
10429
10430 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_1(void * jarg1, int jarg2) {
10431   unsigned int jresult ;
10432   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
10433   Dali::Property::Index arg2 ;
10434   bool result;
10435
10436   arg1 = (Dali::Property::Key *)jarg1;
10437   arg2 = (Dali::Property::Index)jarg2;
10438   {
10439     try {
10440       result = (bool)(arg1)->operator !=(arg2);
10441     } CALL_CATCH_EXCEPTION(0);
10442   }
10443
10444   jresult = result;
10445   return jresult;
10446 }
10447
10448
10449 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_2(void * jarg1, void * jarg2) {
10450   unsigned int jresult ;
10451   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
10452   Dali::Property::Key *arg2 = 0 ;
10453   bool result;
10454
10455   arg1 = (Dali::Property::Key *)jarg1;
10456   arg2 = (Dali::Property::Key *)jarg2;
10457   if (!arg2) {
10458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
10459     return 0;
10460   }
10461   {
10462     try {
10463       result = (bool)(arg1)->operator !=((Dali::Property::Key const &)*arg2);
10464     } CALL_CATCH_EXCEPTION(0);
10465   }
10466
10467   jresult = result;
10468   return jresult;
10469 }
10470
10471
10472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Key(void * jarg1) {
10473   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
10474
10475   arg1 = (Dali::Property::Key *)jarg1;
10476   {
10477     try {
10478       delete arg1;
10479     } CALL_CATCH_EXCEPTION();
10480   }
10481
10482 }
10483
10484
10485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_0() {
10486   void * jresult ;
10487   Dali::Property::Map *result = 0 ;
10488
10489   {
10490     try {
10491       result = (Dali::Property::Map *)new Dali::Property::Map();
10492     } CALL_CATCH_EXCEPTION(0);
10493   }
10494
10495   jresult = (void *)result;
10496   return jresult;
10497 }
10498
10499
10500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_1(void * jarg1) {
10501   void * jresult ;
10502   Dali::Property::Map *arg1 = 0 ;
10503   Dali::Property::Map *result = 0 ;
10504
10505   arg1 = (Dali::Property::Map *)jarg1;
10506   if (!arg1) {
10507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
10508     return 0;
10509   }
10510   {
10511     try {
10512       result = (Dali::Property::Map *)new Dali::Property::Map((Dali::Property::Map const &)*arg1);
10513     } CALL_CATCH_EXCEPTION(0);
10514   }
10515
10516   jresult = (void *)result;
10517   return jresult;
10518 }
10519
10520
10521 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Map(void * jarg1) {
10522   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10523
10524   arg1 = (Dali::Property::Map *)jarg1;
10525   {
10526     try {
10527       delete arg1;
10528     } CALL_CATCH_EXCEPTION();
10529   }
10530
10531 }
10532
10533
10534 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Map_Count(void * jarg1) {
10535   unsigned long jresult ;
10536   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10537   Dali::Property::Map::SizeType result;
10538
10539   arg1 = (Dali::Property::Map *)jarg1;
10540   {
10541     try {
10542       result = ((Dali::Property::Map const *)arg1)->Count();
10543     } CALL_CATCH_EXCEPTION(0);
10544   }
10545
10546   jresult = (unsigned long)result;
10547   return jresult;
10548 }
10549
10550
10551 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Map_Empty(void * jarg1) {
10552   unsigned int jresult ;
10553   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10554   bool result;
10555
10556   arg1 = (Dali::Property::Map *)jarg1;
10557   {
10558     try {
10559       result = (bool)((Dali::Property::Map const *)arg1)->Empty();
10560     } CALL_CATCH_EXCEPTION(0);
10561   }
10562
10563   jresult = result;
10564   return jresult;
10565 }
10566
10567
10568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
10569   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10570   char *arg2 = (char *) 0 ;
10571   Dali::Property::Value *arg3 = 0 ;
10572
10573   arg1 = (Dali::Property::Map *)jarg1;
10574   arg2 = (char *)jarg2;
10575   arg3 = (Dali::Property::Value *)jarg3;
10576   if (!arg3) {
10577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
10578     return ;
10579   }
10580   {
10581     try {
10582       (arg1)->Insert((char const *)arg2,(Dali::Property::Value const &)*arg3);
10583     } CALL_CATCH_EXCEPTION();
10584   }
10585
10586 }
10587
10588
10589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
10590   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10591   Dali::Property::Index arg2 ;
10592   Dali::Property::Value *arg3 = 0 ;
10593
10594   arg1 = (Dali::Property::Map *)jarg1;
10595   arg2 = (Dali::Property::Index)jarg2;
10596   arg3 = (Dali::Property::Value *)jarg3;
10597   if (!arg3) {
10598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
10599     return ;
10600   }
10601   {
10602     try {
10603       (arg1)->Insert(arg2,(Dali::Property::Value const &)*arg3);
10604     } CALL_CATCH_EXCEPTION();
10605   }
10606
10607 }
10608
10609
10610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
10611   void * jresult ;
10612   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10613   char *arg2 = (char *) 0 ;
10614   Dali::Property::Value *arg3 = 0 ;
10615   Dali::Property::Map *result = 0 ;
10616
10617   arg1 = (Dali::Property::Map *)jarg1;
10618   arg2 = (char *)jarg2;
10619   arg3 = (Dali::Property::Value *)jarg3;
10620   if (!arg3) {
10621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
10622     return 0;
10623   }
10624   {
10625     try {
10626       result = (Dali::Property::Map *) &(arg1)->Add((char const *)arg2,(Dali::Property::Value const &)*arg3);
10627     } CALL_CATCH_EXCEPTION(0);
10628   }
10629
10630   jresult = (void *)result;
10631   return jresult;
10632 }
10633
10634
10635 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
10636   void * jresult ;
10637   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10638   Dali::Property::Index arg2 ;
10639   Dali::Property::Value *arg3 = 0 ;
10640   Dali::Property::Map *result = 0 ;
10641
10642   arg1 = (Dali::Property::Map *)jarg1;
10643   arg2 = (Dali::Property::Index)jarg2;
10644   arg3 = (Dali::Property::Value *)jarg3;
10645   if (!arg3) {
10646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
10647     return 0;
10648   }
10649   {
10650     try {
10651       result = (Dali::Property::Map *) &(arg1)->Add(arg2,(Dali::Property::Value const &)*arg3);
10652     } CALL_CATCH_EXCEPTION(0);
10653   }
10654
10655   jresult = (void *)result;
10656   return jresult;
10657 }
10658
10659
10660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetValue(void * jarg1, unsigned long jarg2) {
10661   void * jresult ;
10662   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10663   Dali::Property::Map::SizeType arg2 ;
10664   Dali::Property::Value *result = 0 ;
10665
10666   arg1 = (Dali::Property::Map *)jarg1;
10667   arg2 = (Dali::Property::Map::SizeType)jarg2;
10668   {
10669     try {
10670       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->GetValue(arg2);
10671     } CALL_CATCH_EXCEPTION(0);
10672   }
10673
10674   jresult = (void *)result;
10675   return jresult;
10676 }
10677
10678
10679 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Map_GetKey(void * jarg1, unsigned long jarg2) {
10680   char * jresult ;
10681   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10682   Dali::Property::Map::SizeType arg2 ;
10683   std::string *result = 0 ;
10684
10685   arg1 = (Dali::Property::Map *)jarg1;
10686   arg2 = (Dali::Property::Map::SizeType)jarg2;
10687   {
10688     try {
10689       result = (std::string *) &((Dali::Property::Map const *)arg1)->GetKey(arg2);
10690     } CALL_CATCH_EXCEPTION(0);
10691   }
10692
10693   jresult = SWIG_csharp_string_callback(result->c_str());
10694   return jresult;
10695 }
10696
10697
10698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetKeyAt(void * jarg1, unsigned long jarg2) {
10699   void * jresult ;
10700   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10701   Dali::Property::Map::SizeType arg2 ;
10702   SwigValueWrapper< Dali::Property::Key > result;
10703
10704   arg1 = (Dali::Property::Map *)jarg1;
10705   arg2 = (Dali::Property::Map::SizeType)jarg2;
10706   {
10707     try {
10708       result = ((Dali::Property::Map const *)arg1)->GetKeyAt(arg2);
10709     } CALL_CATCH_EXCEPTION(0);
10710   }
10711
10712   jresult = new Dali::Property::Key((const Dali::Property::Key &)result);
10713   return jresult;
10714 }
10715
10716
10717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetPair(void * jarg1, unsigned long jarg2) {
10718   void * jresult ;
10719   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10720   Dali::Property::Map::SizeType arg2 ;
10721   StringValuePair *result = 0 ;
10722
10723   arg1 = (Dali::Property::Map *)jarg1;
10724   arg2 = (Dali::Property::Map::SizeType)jarg2;
10725   {
10726     try {
10727       result = (StringValuePair *) &((Dali::Property::Map const *)arg1)->GetPair(arg2);
10728     } CALL_CATCH_EXCEPTION(0);
10729   }
10730
10731   jresult = (void *)result;
10732   return jresult;
10733 }
10734
10735
10736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_0(void * jarg1, char * jarg2) {
10737   void * jresult ;
10738   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10739   char *arg2 = (char *) 0 ;
10740   Dali::Property::Value *result = 0 ;
10741
10742   arg1 = (Dali::Property::Map *)jarg1;
10743   arg2 = (char *)jarg2;
10744   {
10745     try {
10746       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((char const *)arg2);
10747     } CALL_CATCH_EXCEPTION(0);
10748   }
10749
10750   jresult = (void *)result;
10751   return jresult;
10752 }
10753
10754
10755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_2(void * jarg1, int jarg2) {
10756   void * jresult ;
10757   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10758   Dali::Property::Index arg2 ;
10759   Dali::Property::Value *result = 0 ;
10760
10761   arg1 = (Dali::Property::Map *)jarg1;
10762   arg2 = (Dali::Property::Index)jarg2;
10763   {
10764     try {
10765       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2);
10766     } CALL_CATCH_EXCEPTION(0);
10767   }
10768
10769   jresult = (void *)result;
10770   return jresult;
10771 }
10772
10773
10774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_3(void * jarg1, int jarg2, char * jarg3) {
10775   void * jresult ;
10776   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10777   Dali::Property::Index arg2 ;
10778   std::string *arg3 = 0 ;
10779   Dali::Property::Value *result = 0 ;
10780
10781   arg1 = (Dali::Property::Map *)jarg1;
10782   arg2 = (Dali::Property::Index)jarg2;
10783   if (!jarg3) {
10784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10785     return 0;
10786   }
10787   std::string arg3_str(jarg3);
10788   arg3 = &arg3_str;
10789   {
10790     try {
10791       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,(std::string const &)*arg3);
10792     } CALL_CATCH_EXCEPTION(0);
10793   }
10794
10795   jresult = (void *)result;
10796
10797   //argout typemap for const std::string&
10798
10799   return jresult;
10800 }
10801
10802
10803 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_4(void * jarg1, char * jarg2, int jarg3) {
10804   void * jresult ;
10805   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10806   std::string *arg2 = 0 ;
10807   Dali::Property::Type arg3 ;
10808   Dali::Property::Value *result = 0 ;
10809
10810   arg1 = (Dali::Property::Map *)jarg1;
10811   if (!jarg2) {
10812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10813     return 0;
10814   }
10815   std::string arg2_str(jarg2);
10816   arg2 = &arg2_str;
10817   arg3 = (Dali::Property::Type)jarg3;
10818   {
10819     try {
10820       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((std::string const &)*arg2,arg3);
10821     } CALL_CATCH_EXCEPTION(0);
10822   }
10823
10824   jresult = (void *)result;
10825
10826   //argout typemap for const std::string&
10827
10828   return jresult;
10829 }
10830
10831
10832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_5(void * jarg1, int jarg2, int jarg3) {
10833   void * jresult ;
10834   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10835   Dali::Property::Index arg2 ;
10836   Dali::Property::Type arg3 ;
10837   Dali::Property::Value *result = 0 ;
10838
10839   arg1 = (Dali::Property::Map *)jarg1;
10840   arg2 = (Dali::Property::Index)jarg2;
10841   arg3 = (Dali::Property::Type)jarg3;
10842   {
10843     try {
10844       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,arg3);
10845     } CALL_CATCH_EXCEPTION(0);
10846   }
10847
10848   jresult = (void *)result;
10849   return jresult;
10850 }
10851
10852
10853 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Clear(void * jarg1) {
10854   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10855
10856   arg1 = (Dali::Property::Map *)jarg1;
10857   {
10858     try {
10859       (arg1)->Clear();
10860     } CALL_CATCH_EXCEPTION();
10861   }
10862
10863 }
10864
10865
10866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Merge(void * jarg1, void * jarg2) {
10867   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10868   Dali::Property::Map *arg2 = 0 ;
10869
10870   arg1 = (Dali::Property::Map *)jarg1;
10871   arg2 = (Dali::Property::Map *)jarg2;
10872   if (!arg2) {
10873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
10874     return ;
10875   }
10876   {
10877     try {
10878       (arg1)->Merge((Dali::Property::Map const &)*arg2);
10879     } CALL_CATCH_EXCEPTION();
10880   }
10881
10882 }
10883
10884
10885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_0(void * jarg1, char * jarg2) {
10886   void * jresult ;
10887   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10888   std::string *arg2 = 0 ;
10889   Dali::Property::Value *result = 0 ;
10890
10891   arg1 = (Dali::Property::Map *)jarg1;
10892   if (!jarg2) {
10893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10894     return 0;
10895   }
10896   std::string arg2_str(jarg2);
10897   arg2 = &arg2_str;
10898   {
10899     try {
10900       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator []((std::string const &)*arg2);
10901     } CALL_CATCH_EXCEPTION(0);
10902   }
10903
10904   jresult = (void *)result;
10905
10906   //argout typemap for const std::string&
10907
10908   return jresult;
10909 }
10910
10911
10912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_2(void * jarg1, int jarg2) {
10913   void * jresult ;
10914   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10915   Dali::Property::Index arg2 ;
10916   Dali::Property::Value *result = 0 ;
10917
10918   arg1 = (Dali::Property::Map *)jarg1;
10919   arg2 = (Dali::Property::Index)jarg2;
10920   {
10921     try {
10922       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator [](arg2);
10923     } CALL_CATCH_EXCEPTION(0);
10924   }
10925
10926   jresult = (void *)result;
10927   return jresult;
10928 }
10929
10930
10931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Assign(void * jarg1, void * jarg2) {
10932   void * jresult ;
10933   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10934   Dali::Property::Map *arg2 = 0 ;
10935   Dali::Property::Map *result = 0 ;
10936
10937   arg1 = (Dali::Property::Map *)jarg1;
10938   arg2 = (Dali::Property::Map *)jarg2;
10939   if (!arg2) {
10940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
10941     return 0;
10942   }
10943   {
10944     try {
10945       result = (Dali::Property::Map *) &(arg1)->operator =((Dali::Property::Map const &)*arg2);
10946     } CALL_CATCH_EXCEPTION(0);
10947   }
10948
10949   jresult = (void *)result;
10950   return jresult;
10951 }
10952
10953
10954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_StringKey(void* jarg1, char* jarg2, void* jarg3) {
10955
10956   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
10957
10958   if (!jarg2) {
10959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10960     return;
10961   }
10962   std::string arg2_str(jarg2);
10963   std::string* arg2 = &arg2_str;
10964
10965   Dali::Property::Value* arg3 = (Dali::Property::Value*)jarg3;
10966
10967   {
10968     try {
10969       arg1->operator[]((std::string const &)*arg2) = *arg3;
10970     } CALL_CATCH_EXCEPTION();
10971   }
10972 }
10973
10974
10975 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_IntKey(void* jarg1, int jarg2, void* jarg3) {
10976
10977   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
10978   Dali::Property::Index arg2 = (Dali::Property::Index)jarg2;
10979   Dali::Property::Value* arg3 = (Dali::Property::Value*)jarg3;
10980
10981   {
10982     try {
10983       arg1->operator[](arg2) = *arg3;
10984     } CALL_CATCH_EXCEPTION();
10985   }
10986 }
10987
10988
10989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_0() {
10990   void * jresult ;
10991   Dali::Property::Value *result = 0 ;
10992
10993   {
10994     try {
10995       result = (Dali::Property::Value *)new Dali::Property::Value();
10996     } CALL_CATCH_EXCEPTION(0);
10997   }
10998
10999   jresult = (void *)result;
11000   return jresult;
11001 }
11002
11003
11004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_1(unsigned int jarg1) {
11005   void * jresult ;
11006   bool arg1 ;
11007   Dali::Property::Value *result = 0 ;
11008
11009   arg1 = jarg1 ? true : false;
11010   {
11011     try {
11012       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
11013     } CALL_CATCH_EXCEPTION(0);
11014   }
11015
11016   jresult = (void *)result;
11017   return jresult;
11018 }
11019
11020
11021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_2(int jarg1) {
11022   void * jresult ;
11023   int arg1 ;
11024   Dali::Property::Value *result = 0 ;
11025
11026   arg1 = (int)jarg1;
11027   {
11028     try {
11029       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
11030     } CALL_CATCH_EXCEPTION(0);
11031   }
11032
11033   jresult = (void *)result;
11034   return jresult;
11035 }
11036
11037
11038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_3(float jarg1) {
11039   void * jresult ;
11040   float arg1 ;
11041   Dali::Property::Value *result = 0 ;
11042
11043   arg1 = (float)jarg1;
11044   {
11045     try {
11046       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
11047     } CALL_CATCH_EXCEPTION(0);
11048   }
11049
11050   jresult = (void *)result;
11051   return jresult;
11052 }
11053
11054
11055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_4(void * jarg1) {
11056   void * jresult ;
11057   Dali::Vector2 *arg1 = 0 ;
11058   Dali::Property::Value *result = 0 ;
11059
11060   arg1 = (Dali::Vector2 *)jarg1;
11061   if (!arg1) {
11062     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
11063     return 0;
11064   }
11065   {
11066     try {
11067       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector2 const &)*arg1);
11068     } CALL_CATCH_EXCEPTION(0);
11069   }
11070
11071   jresult = (void *)result;
11072   return jresult;
11073 }
11074
11075
11076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_5(void * jarg1) {
11077   void * jresult ;
11078   Dali::Vector3 *arg1 = 0 ;
11079   Dali::Property::Value *result = 0 ;
11080
11081   arg1 = (Dali::Vector3 *)jarg1;
11082   if (!arg1) {
11083     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11084     return 0;
11085   }
11086   {
11087     try {
11088       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector3 const &)*arg1);
11089     } CALL_CATCH_EXCEPTION(0);
11090   }
11091
11092   jresult = (void *)result;
11093   return jresult;
11094 }
11095
11096
11097 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_6(void * jarg1) {
11098   void * jresult ;
11099   Dali::Vector4 *arg1 = 0 ;
11100   Dali::Property::Value *result = 0 ;
11101
11102   arg1 = (Dali::Vector4 *)jarg1;
11103   if (!arg1) {
11104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
11105     return 0;
11106   }
11107   {
11108     try {
11109       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector4 const &)*arg1);
11110     } CALL_CATCH_EXCEPTION(0);
11111   }
11112
11113   jresult = (void *)result;
11114   return jresult;
11115 }
11116
11117
11118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_7(void * jarg1) {
11119   void * jresult ;
11120   Dali::Matrix3 *arg1 = 0 ;
11121   Dali::Property::Value *result = 0 ;
11122
11123   arg1 = (Dali::Matrix3 *)jarg1;
11124   if (!arg1) {
11125     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
11126     return 0;
11127   }
11128   {
11129     try {
11130       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix3 const &)*arg1);
11131     } CALL_CATCH_EXCEPTION(0);
11132   }
11133
11134   jresult = (void *)result;
11135   return jresult;
11136 }
11137
11138
11139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_8(void * jarg1) {
11140   void * jresult ;
11141   Dali::Matrix *arg1 = 0 ;
11142   Dali::Property::Value *result = 0 ;
11143
11144   arg1 = (Dali::Matrix *)jarg1;
11145   if (!arg1) {
11146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11147     return 0;
11148   }
11149   {
11150     try {
11151       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix const &)*arg1);
11152     } CALL_CATCH_EXCEPTION(0);
11153   }
11154
11155   jresult = (void *)result;
11156   return jresult;
11157 }
11158
11159
11160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_9(void * jarg1) {
11161   void * jresult ;
11162   Dali::Rect< int > *arg1 = 0 ;
11163   Dali::Property::Value *result = 0 ;
11164
11165   arg1 = (Dali::Rect< int > *)jarg1;
11166   if (!arg1) {
11167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
11168     return 0;
11169   }
11170   {
11171     try {
11172       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Rect< int > const &)*arg1);
11173     } CALL_CATCH_EXCEPTION(0);
11174   }
11175
11176   jresult = (void *)result;
11177   return jresult;
11178 }
11179
11180
11181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_10(void * jarg1) {
11182   void * jresult ;
11183   Dali::AngleAxis *arg1 = 0 ;
11184   Dali::Property::Value *result = 0 ;
11185
11186   arg1 = (Dali::AngleAxis *)jarg1;
11187   if (!arg1) {
11188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
11189     return 0;
11190   }
11191   {
11192     try {
11193       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::AngleAxis const &)*arg1);
11194     } CALL_CATCH_EXCEPTION(0);
11195   }
11196
11197   jresult = (void *)result;
11198   return jresult;
11199 }
11200
11201
11202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_11(void * jarg1) {
11203   void * jresult ;
11204   Dali::Quaternion *arg1 = 0 ;
11205   Dali::Property::Value *result = 0 ;
11206
11207   arg1 = (Dali::Quaternion *)jarg1;
11208   if (!arg1) {
11209     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11210     return 0;
11211   }
11212   {
11213     try {
11214       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Quaternion const &)*arg1);
11215     } CALL_CATCH_EXCEPTION(0);
11216   }
11217
11218   jresult = (void *)result;
11219   return jresult;
11220 }
11221
11222
11223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_12(char * jarg1) {
11224   void * jresult ;
11225   std::string *arg1 = 0 ;
11226   Dali::Property::Value *result = 0 ;
11227
11228   if (!jarg1) {
11229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
11230     return 0;
11231   }
11232   std::string arg1_str(jarg1);
11233   arg1 = &arg1_str;
11234   {
11235     try {
11236       result = (Dali::Property::Value *)new Dali::Property::Value((std::string const &)*arg1);
11237     } CALL_CATCH_EXCEPTION(0);
11238   }
11239
11240   jresult = (void *)result;
11241
11242   //argout typemap for const std::string&
11243
11244   return jresult;
11245 }
11246
11247
11248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_14(void * jarg1) {
11249   void * jresult ;
11250   Dali::Property::Array *arg1 = 0 ;
11251   Dali::Property::Value *result = 0 ;
11252
11253   arg1 = (Dali::Property::Array *)jarg1;
11254   if (!arg1) {
11255     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
11256     return 0;
11257   }
11258   {
11259     try {
11260       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
11261     } CALL_CATCH_EXCEPTION(0);
11262   }
11263
11264   jresult = (void *)result;
11265   return jresult;
11266 }
11267
11268
11269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_15(void * jarg1) {
11270   void * jresult ;
11271   Dali::Property::Map *arg1 = 0 ;
11272   Dali::Property::Value *result = 0 ;
11273
11274   arg1 = (Dali::Property::Map *)jarg1;
11275   if (!arg1) {
11276     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
11277     return 0;
11278   }
11279   {
11280     try {
11281       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
11282     } CALL_CATCH_EXCEPTION(0);
11283   }
11284
11285   jresult = (void *)result;
11286   return jresult;
11287 }
11288
11289
11290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_16(void * jarg1) {
11291   void * jresult ;
11292   Extents *arg1 = 0 ;
11293   Dali::Property::Value *result = 0 ;
11294
11295   arg1 = (Extents *)jarg1;
11296   if (!arg1) {
11297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents const & type is null", 0);
11298     return 0;
11299   }
11300   {
11301     try {
11302       result = (Dali::Property::Value *)new Dali::Property::Value((Extents const &)*arg1);
11303     } CALL_CATCH_EXCEPTION(0);
11304   }
11305
11306   jresult = (void*) result;
11307   return jresult;
11308 }
11309
11310
11311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_17(int jarg1) {
11312   void * jresult ;
11313   Dali::Property::Type arg1 ;
11314   Dali::Property::Value *result = 0 ;
11315
11316   arg1 = (Dali::Property::Type)jarg1;
11317   {
11318     try {
11319       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
11320     } CALL_CATCH_EXCEPTION(0);
11321   }
11322
11323   jresult = (void *)result;
11324   return jresult;
11325 }
11326
11327
11328 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_18(void * jarg1) {
11329   void * jresult ;
11330   Dali::Property::Value *arg1 = 0 ;
11331   Dali::Property::Value *result = 0 ;
11332
11333   arg1 = (Dali::Property::Value *)jarg1;
11334   if (!arg1) {
11335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
11336     return 0;
11337   }
11338   {
11339     try {
11340       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Property::Value const &)*arg1);
11341     } CALL_CATCH_EXCEPTION(0);
11342   }
11343
11344   jresult = (void *)result;
11345   return jresult;
11346 }
11347
11348
11349 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_Assign(void * jarg1, void * jarg2) {
11350   void * jresult ;
11351   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11352   Dali::Property::Value *arg2 = 0 ;
11353   Dali::Property::Value *result = 0 ;
11354
11355   arg1 = (Dali::Property::Value *)jarg1;
11356   arg2 = (Dali::Property::Value *)jarg2;
11357   if (!arg2) {
11358     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
11359     return 0;
11360   }
11361   {
11362     try {
11363       result = (Dali::Property::Value *) &(arg1)->operator =((Dali::Property::Value const &)*arg2);
11364     } CALL_CATCH_EXCEPTION(0);
11365   }
11366
11367   jresult = (void *)result;
11368   return jresult;
11369 }
11370
11371
11372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Value(void * jarg1) {
11373   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11374
11375   arg1 = (Dali::Property::Value *)jarg1;
11376   {
11377     try {
11378       delete arg1;
11379     } CALL_CATCH_EXCEPTION();
11380   }
11381
11382 }
11383
11384
11385 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Value_GetType(void * jarg1) {
11386   int jresult ;
11387   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11388   Dali::Property::Type result;
11389
11390   arg1 = (Dali::Property::Value *)jarg1;
11391   {
11392     try {
11393       result = (Dali::Property::Type)((Dali::Property::Value const *)arg1)->GetType();
11394     } CALL_CATCH_EXCEPTION(0);
11395   }
11396
11397   jresult = (int)result;
11398   return jresult;
11399 }
11400
11401
11402 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_1(void * jarg1, unsigned int * jarg2) {
11403   unsigned int jresult ;
11404   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11405   bool *arg2 = 0 ;
11406   bool result;
11407
11408   arg1 = (Dali::Property::Value *)jarg1;
11409   arg2 = (bool *)jarg2;
11410   {
11411     try {
11412       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11413     } CALL_CATCH_EXCEPTION(0);
11414   }
11415
11416   jresult = result;
11417   return jresult;
11418 }
11419
11420
11421 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_2(void * jarg1, float * jarg2) {
11422   unsigned int jresult ;
11423   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11424   float *arg2 = 0 ;
11425   bool result;
11426
11427   arg1 = (Dali::Property::Value *)jarg1;
11428   arg2 = (float *)jarg2;
11429   {
11430     try {
11431       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11432     } CALL_CATCH_EXCEPTION(0);
11433   }
11434
11435   jresult = result;
11436   return jresult;
11437 }
11438
11439
11440 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_3(void * jarg1, int * jarg2) {
11441   unsigned int jresult ;
11442   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11443   int *arg2 = 0 ;
11444   bool result;
11445
11446   arg1 = (Dali::Property::Value *)jarg1;
11447   arg2 = (int *)jarg2;
11448   {
11449     try {
11450       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11451     } CALL_CATCH_EXCEPTION(0);
11452   }
11453
11454   jresult = result;
11455   return jresult;
11456 }
11457
11458
11459 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_4(void * jarg1, void * jarg2) {
11460   unsigned int jresult ;
11461   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11462   Dali::Rect< int > *arg2 = 0 ;
11463   bool result;
11464
11465   arg1 = (Dali::Property::Value *)jarg1;
11466   arg2 = (Dali::Rect< int > *)jarg2;
11467   if (!arg2) {
11468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > & type is null", 0);
11469     return 0;
11470   }
11471   {
11472     try {
11473       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11474     } CALL_CATCH_EXCEPTION(0);
11475   }
11476
11477   jresult = result;
11478   return jresult;
11479 }
11480
11481
11482 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_5(void * jarg1, void * jarg2) {
11483   unsigned int jresult ;
11484   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11485   Dali::Vector2 *arg2 = 0 ;
11486   bool result;
11487
11488   arg1 = (Dali::Property::Value *)jarg1;
11489   arg2 = (Dali::Vector2 *)jarg2;
11490   if (!arg2) {
11491     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
11492     return 0;
11493   }
11494   {
11495     try {
11496       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11497     } CALL_CATCH_EXCEPTION(0);
11498   }
11499
11500   jresult = result;
11501   return jresult;
11502 }
11503
11504
11505 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_6(void * jarg1, void * jarg2) {
11506   unsigned int jresult ;
11507   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11508   Dali::Vector3 *arg2 = 0 ;
11509   bool result;
11510
11511   arg1 = (Dali::Property::Value *)jarg1;
11512   arg2 = (Dali::Vector3 *)jarg2;
11513   if (!arg2) {
11514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11515     return 0;
11516   }
11517   {
11518     try {
11519       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11520     } CALL_CATCH_EXCEPTION(0);
11521   }
11522
11523   jresult = result;
11524   return jresult;
11525 }
11526
11527
11528 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_7(void * jarg1, void * jarg2) {
11529   unsigned int jresult ;
11530   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11531   Dali::Vector4 *arg2 = 0 ;
11532   bool result;
11533
11534   arg1 = (Dali::Property::Value *)jarg1;
11535   arg2 = (Dali::Vector4 *)jarg2;
11536   if (!arg2) {
11537     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 & type is null", 0);
11538     return 0;
11539   }
11540   {
11541     try {
11542       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11543     } CALL_CATCH_EXCEPTION(0);
11544   }
11545
11546   jresult = result;
11547   return jresult;
11548 }
11549
11550
11551 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_8(void * jarg1, void * jarg2) {
11552   unsigned int jresult ;
11553   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11554   Dali::Matrix3 *arg2 = 0 ;
11555   bool result;
11556
11557   arg1 = (Dali::Property::Value *)jarg1;
11558   arg2 = (Dali::Matrix3 *)jarg2;
11559   if (!arg2) {
11560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
11561     return 0;
11562   }
11563   {
11564     try {
11565       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11566     } CALL_CATCH_EXCEPTION(0);
11567   }
11568
11569   jresult = result;
11570   return jresult;
11571 }
11572
11573
11574 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_9(void * jarg1, void * jarg2) {
11575   unsigned int jresult ;
11576   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11577   Dali::Matrix *arg2 = 0 ;
11578   bool result;
11579
11580   arg1 = (Dali::Property::Value *)jarg1;
11581   arg2 = (Dali::Matrix *)jarg2;
11582   if (!arg2) {
11583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
11584     return 0;
11585   }
11586   {
11587     try {
11588       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11589     } CALL_CATCH_EXCEPTION(0);
11590   }
11591
11592   jresult = result;
11593   return jresult;
11594 }
11595
11596
11597 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_10(void * jarg1, void * jarg2) {
11598   unsigned int jresult ;
11599   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11600   Dali::AngleAxis *arg2 = 0 ;
11601   bool result;
11602
11603   arg1 = (Dali::Property::Value *)jarg1;
11604   arg2 = (Dali::AngleAxis *)jarg2;
11605   if (!arg2) {
11606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis & type is null", 0);
11607     return 0;
11608   }
11609   {
11610     try {
11611       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11612     } CALL_CATCH_EXCEPTION(0);
11613   }
11614
11615   jresult = result;
11616   return jresult;
11617 }
11618
11619
11620 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_11(void * jarg1, void * jarg2) {
11621   unsigned int jresult ;
11622   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11623   Dali::Quaternion *arg2 = 0 ;
11624   bool result;
11625
11626   arg1 = (Dali::Property::Value *)jarg1;
11627   arg2 = (Dali::Quaternion *)jarg2;
11628   if (!arg2) {
11629     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
11630     return 0;
11631   }
11632   {
11633     try {
11634       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11635     } CALL_CATCH_EXCEPTION(0);
11636   }
11637
11638   jresult = result;
11639   return jresult;
11640 }
11641
11642
11643 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_12(void * jarg1, char** jarg2) {
11644   unsigned int jresult ;
11645   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11646   std::string *arg2 = 0 ;
11647   bool result;
11648
11649   arg1 = (Dali::Property::Value *)jarg1;
11650
11651   //typemap in
11652   std::string temp;
11653   arg2 = &temp;
11654
11655   {
11656     try {
11657       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11658     } CALL_CATCH_EXCEPTION(0);
11659   }
11660
11661   jresult = result;
11662
11663   //Typemap argout in c++ file.
11664   //This will convert c++ string to c# string
11665   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
11666
11667   return jresult;
11668 }
11669
11670
11671 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_13(void * jarg1, void * jarg2) {
11672   unsigned int jresult ;
11673   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11674   Dali::Property::Array *arg2 = 0 ;
11675   bool result;
11676
11677   arg1 = (Dali::Property::Value *)jarg1;
11678   arg2 = (Dali::Property::Array *)jarg2;
11679   if (!arg2) {
11680     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
11681     return 0;
11682   }
11683   {
11684     try {
11685       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11686     } CALL_CATCH_EXCEPTION(0);
11687   }
11688
11689   jresult = result;
11690   return jresult;
11691 }
11692
11693
11694 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_14(void * jarg1, void * jarg2) {
11695   unsigned int jresult ;
11696   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11697   Dali::Property::Map *arg2 = 0 ;
11698   bool result;
11699
11700   arg1 = (Dali::Property::Value *)jarg1;
11701   arg2 = (Dali::Property::Map *)jarg2;
11702   if (!arg2) {
11703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
11704     return 0;
11705   }
11706   {
11707     try {
11708       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11709     } CALL_CATCH_EXCEPTION(0);
11710   }
11711
11712   jresult = result;
11713   return jresult;
11714 }
11715
11716
11717 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_15(void * jarg1, void * jarg2) {
11718   unsigned int jresult ;
11719   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11720   Extents *arg2 = 0 ;
11721   bool result;
11722
11723   arg1 = (Dali::Property::Value *)jarg1;
11724   arg2 = (Extents *)jarg2;
11725   if (!arg2) {
11726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents & type is null", 0);
11727     return 0;
11728   }
11729   {
11730     try {
11731       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11732     } CALL_CATCH_EXCEPTION(0);
11733   }
11734   jresult = result;
11735   return jresult;
11736 }
11737
11738 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetArray(void * jarg1) {
11739   void * jresult ;
11740   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11741   Dali::Property::Array *result = 0 ;
11742
11743   arg1 = (Dali::Property::Value *)jarg1;
11744   {
11745     try {
11746       result = (Dali::Property::Array *)((Dali::Property::Value const *)arg1)->GetArray();
11747     } CALL_CATCH_EXCEPTION(0);
11748   }
11749
11750   jresult = (void *)result;
11751   return jresult;
11752 }
11753
11754
11755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetMap(void * jarg1) {
11756   void * jresult ;
11757   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11758   Dali::Property::Map *result = 0 ;
11759
11760   arg1 = (Dali::Property::Value *)jarg1;
11761   {
11762     try {
11763       result = (Dali::Property::Map *)((Dali::Property::Value const *)arg1)->GetMap();
11764     } CALL_CATCH_EXCEPTION(0);
11765   }
11766
11767   jresult = (void *)result;
11768   return jresult;
11769 }
11770
11771
11772 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetName(int jarg1) {
11773   char * jresult ;
11774   Dali::Property::Type arg1 ;
11775   char *result = 0 ;
11776
11777   arg1 = (Dali::Property::Type)jarg1;
11778   {
11779     try {
11780       result = (char *)Dali::PropertyTypes::GetName(arg1);
11781     } CALL_CATCH_EXCEPTION(0);
11782   }
11783
11784   jresult = SWIG_csharp_string_callback((const char *)result);
11785   return jresult;
11786 }
11787
11788
11789 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoAction(void * jarg1, char * jarg2, void * jarg3) {
11790   unsigned int jresult ;
11791   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
11792   std::string *arg2 = 0 ;
11793   Dali::Property::Map *arg3 = 0 ;
11794   bool result;
11795
11796   arg1 = (Dali::BaseObject *)jarg1;
11797   if (!jarg2) {
11798     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
11799     return 0;
11800   }
11801   std::string arg2_str(jarg2);
11802   arg2 = &arg2_str;
11803   arg3 = (Dali::Property::Map *)jarg3;
11804   if (!arg3) {
11805     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
11806     return 0;
11807   }
11808   {
11809     try {
11810       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
11811     } CALL_CATCH_EXCEPTION(0);
11812   }
11813
11814   jresult = result;
11815
11816   //argout typemap for const std::string&
11817
11818   return jresult;
11819 }
11820
11821
11822 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeName(void * jarg1) {
11823   char * jresult ;
11824   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
11825   std::string *result = 0 ;
11826
11827   arg1 = (Dali::BaseObject *)jarg1;
11828   {
11829     try {
11830       result = (std::string *) &((Dali::BaseObject const *)arg1)->GetTypeName();
11831     } CALL_CATCH_EXCEPTION(0);
11832   }
11833
11834   jresult = SWIG_csharp_string_callback(result->c_str());
11835   return jresult;
11836 }
11837
11838
11839 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeInfo(void * jarg1, void * jarg2) {
11840   unsigned int jresult ;
11841   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
11842   Dali::TypeInfo *arg2 = 0 ;
11843   bool result;
11844
11845   arg1 = (Dali::BaseObject *)jarg1;
11846   arg2 = (Dali::TypeInfo *)jarg2;
11847   if (!arg2) {
11848     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
11849     return 0;
11850   }
11851   {
11852     try {
11853       result = (bool)((Dali::BaseObject const *)arg1)->GetTypeInfo(*arg2);
11854     } CALL_CATCH_EXCEPTION(0);
11855   }
11856
11857   jresult = result;
11858   return jresult;
11859 }
11860
11861
11862 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoConnectSignal(void * jarg1, void * jarg2, char * jarg3, void * jarg4) {
11863   unsigned int jresult ;
11864   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
11865   ConnectionTrackerInterface *arg2 = (ConnectionTrackerInterface *) 0 ;
11866   std::string *arg3 = 0 ;
11867   FunctorDelegate *arg4 = (FunctorDelegate *) 0 ;
11868   bool result;
11869
11870   arg1 = (Dali::BaseObject *)jarg1;
11871   arg2 = (ConnectionTrackerInterface *)jarg2;
11872   if (!jarg3) {
11873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
11874     return 0;
11875   }
11876   std::string arg3_str(jarg3);
11877   arg3 = &arg3_str;
11878   arg4 = (FunctorDelegate *)jarg4;
11879   {
11880     try {
11881       result = (bool)(arg1)->DoConnectSignal(arg2,(std::string const &)*arg3,arg4);
11882     } CALL_CATCH_EXCEPTION(0);
11883   }
11884
11885   jresult = result;
11886
11887   //argout typemap for const std::string&
11888
11889   return jresult;
11890 }
11891
11892
11893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation(void * jarg1) {
11894   void * jresult ;
11895   Dali::BaseHandle *arg1 = 0 ;
11896   Dali::BaseObject *result = 0 ;
11897
11898   arg1 = (Dali::BaseHandle *)jarg1;
11899   if (!arg1) {
11900     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
11901     return 0;
11902   }
11903   {
11904     try {
11905       result = (Dali::BaseObject *) &Dali::GetImplementation((Dali::BaseHandle const &)*arg1);
11906     } CALL_CATCH_EXCEPTION(0);
11907   }
11908
11909   jresult = (void *)result;
11910   return jresult;
11911 }
11912
11913
11914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_0(void * jarg1) {
11915   void * jresult ;
11916   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
11917   Dali::BaseHandle *result = 0 ;
11918
11919   arg1 = (Dali::BaseObject *)jarg1;
11920   {
11921     try {
11922       result = (Dali::BaseHandle *)new Dali::BaseHandle(arg1);
11923     } CALL_CATCH_EXCEPTION(0);
11924   }
11925
11926   jresult = (void *)result;
11927   return jresult;
11928 }
11929
11930
11931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_1() {
11932   void * jresult ;
11933   Dali::BaseHandle *result = 0 ;
11934
11935   {
11936     try {
11937       result = (Dali::BaseHandle *)new Dali::BaseHandle();
11938     } CALL_CATCH_EXCEPTION(0);
11939   }
11940
11941   jresult = (void *)result;
11942   return jresult;
11943 }
11944
11945
11946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BaseHandle(void * jarg1) {
11947   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
11948
11949   arg1 = (Dali::BaseHandle *)jarg1;
11950   {
11951     try {
11952       delete arg1;
11953     } CALL_CATCH_EXCEPTION();
11954   }
11955
11956 }
11957
11958
11959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_2(void * jarg1) {
11960   void * jresult ;
11961   Dali::BaseHandle *arg1 = 0 ;
11962   Dali::BaseHandle *result = 0 ;
11963
11964   arg1 = (Dali::BaseHandle *)jarg1;
11965   if (!arg1) {
11966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
11967     return 0;
11968   }
11969   {
11970     try {
11971       result = (Dali::BaseHandle *)new Dali::BaseHandle((Dali::BaseHandle const &)*arg1);
11972     } CALL_CATCH_EXCEPTION(0);
11973   }
11974
11975   jresult = (void *)result;
11976   return jresult;
11977 }
11978
11979
11980 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_Assign(void * jarg1, void * jarg2) {
11981   void * jresult ;
11982   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
11983   Dali::BaseHandle *arg2 = 0 ;
11984   Dali::BaseHandle *result = 0 ;
11985
11986   arg1 = (Dali::BaseHandle *)jarg1;
11987   arg2 = (Dali::BaseHandle *)jarg2;
11988   if (!arg2) {
11989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
11990     return 0;
11991   }
11992   {
11993     try {
11994       result = (Dali::BaseHandle *) &(arg1)->operator =((Dali::BaseHandle const &)*arg2);
11995     } CALL_CATCH_EXCEPTION(0);
11996   }
11997
11998   jresult = (void *)result;
11999   return jresult;
12000 }
12001
12002
12003 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_DoAction(void * jarg1, char * jarg2, void * jarg3) {
12004   unsigned int jresult ;
12005   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
12006   std::string *arg2 = 0 ;
12007   Dali::Property::Map *arg3 = 0 ;
12008   bool result;
12009
12010   arg1 = (Dali::BaseHandle *)jarg1;
12011   if (!jarg2) {
12012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
12013     return 0;
12014   }
12015   std::string arg2_str(jarg2);
12016   arg2 = &arg2_str;
12017   arg3 = (Dali::Property::Map *)jarg3;
12018   if (!arg3) {
12019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
12020     return 0;
12021   }
12022   {
12023     try {
12024       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
12025     } CALL_CATCH_EXCEPTION(0);
12026   }
12027
12028   jresult = result;
12029
12030   //argout typemap for const std::string&
12031
12032   return jresult;
12033 }
12034
12035
12036 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeName(void * jarg1) {
12037   char * jresult ;
12038   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
12039   std::string *result = 0 ;
12040
12041   arg1 = (Dali::BaseHandle *)jarg1;
12042   {
12043     try {
12044       result = (std::string *) &((Dali::BaseHandle const *)arg1)->GetTypeName();
12045     } CALL_CATCH_EXCEPTION(0);
12046   }
12047
12048   jresult = SWIG_csharp_string_callback(result->c_str());
12049   return jresult;
12050 }
12051
12052
12053 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeInfo(void * jarg1, void * jarg2) {
12054   unsigned int jresult ;
12055   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
12056   Dali::TypeInfo *arg2 = 0 ;
12057   bool result;
12058
12059   arg1 = (Dali::BaseHandle *)jarg1;
12060   arg2 = (Dali::TypeInfo *)jarg2;
12061   if (!arg2) {
12062     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
12063     return 0;
12064   }
12065   {
12066     try {
12067       result = (bool)((Dali::BaseHandle const *)arg1)->GetTypeInfo(*arg2);
12068     } CALL_CATCH_EXCEPTION(0);
12069   }
12070
12071   jresult = result;
12072   return jresult;
12073 }
12074
12075
12076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetBaseObject__SWIG_0(void * jarg1) {
12077   void * jresult ;
12078   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
12079   Dali::BaseObject *result = 0 ;
12080
12081   arg1 = (Dali::BaseHandle *)jarg1;
12082   {
12083     try {
12084       result = (Dali::BaseObject *) &(arg1)->GetBaseObject();
12085     } CALL_CATCH_EXCEPTION(0);
12086   }
12087
12088   jresult = (void *)result;
12089   return jresult;
12090 }
12091
12092
12093 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BaseHandle_Reset(void * jarg1) {
12094   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
12095
12096   arg1 = (Dali::BaseHandle *)jarg1;
12097   {
12098     try {
12099       (arg1)->Reset();
12100     } CALL_CATCH_EXCEPTION();
12101   }
12102
12103 }
12104
12105
12106 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_EqualTo(void * jarg1, void * jarg2) {
12107   unsigned int jresult ;
12108   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
12109   Dali::BaseHandle *arg2 = 0 ;
12110   bool result;
12111
12112   arg1 = (Dali::BaseHandle *)jarg1;
12113   arg2 = (Dali::BaseHandle *)jarg2;
12114   if (!arg2) {
12115     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
12116     return 0;
12117   }
12118   {
12119     try {
12120       result = (bool)((Dali::BaseHandle const *)arg1)->operator ==((Dali::BaseHandle const &)*arg2);
12121     } CALL_CATCH_EXCEPTION(0);
12122   }
12123
12124   jresult = result;
12125   return jresult;
12126 }
12127
12128
12129 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_NotEqualTo(void * jarg1, void * jarg2) {
12130   unsigned int jresult ;
12131   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
12132   Dali::BaseHandle *arg2 = 0 ;
12133   bool result;
12134
12135   arg1 = (Dali::BaseHandle *)jarg1;
12136   arg2 = (Dali::BaseHandle *)jarg2;
12137   if (!arg2) {
12138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
12139     return 0;
12140   }
12141   {
12142     try {
12143       result = (bool)((Dali::BaseHandle const *)arg1)->operator !=((Dali::BaseHandle const &)*arg2);
12144     } CALL_CATCH_EXCEPTION(0);
12145   }
12146
12147   jresult = result;
12148   return jresult;
12149 }
12150
12151
12152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetObjectPtr(void * jarg1) {
12153   void * jresult ;
12154   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
12155   Dali::RefObject *result = 0 ;
12156
12157   arg1 = (Dali::BaseHandle *)jarg1;
12158   {
12159     try {
12160       result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
12161     } CALL_CATCH_EXCEPTION(0);
12162   }
12163
12164   jresult = (void *)result;
12165   return jresult;
12166 }
12167
12168
12169 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_HasBody(void * jarg1) {
12170   unsigned int jresult ;
12171   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
12172   bool result;
12173
12174   arg1 = (Dali::BaseHandle *)jarg1;
12175   {
12176     try {
12177       result = (bool)Dali_BaseHandle_HasBody((Dali::BaseHandle const *)arg1);
12178     } CALL_CATCH_EXCEPTION(0);
12179   }
12180
12181   jresult = result;
12182   return jresult;
12183 }
12184
12185
12186 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_IsEqual(void * jarg1, void * jarg2) {
12187   unsigned int jresult ;
12188   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
12189   Dali::BaseHandle *arg2 = 0 ;
12190   bool result;
12191
12192   arg1 = (Dali::BaseHandle *)jarg1;
12193   arg2 = (Dali::BaseHandle *)jarg2;
12194   if (!arg2) {
12195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
12196     return 0;
12197   }
12198   {
12199     try {
12200       result = (bool)Dali_BaseHandle_IsEqual((Dali::BaseHandle const *)arg1,(Dali::BaseHandle const &)*arg2);
12201     } CALL_CATCH_EXCEPTION(0);
12202   }
12203
12204   jresult = result;
12205   return jresult;
12206 }
12207
12208
12209 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_3(void * jarg1, void * jarg2) {
12210   unsigned int jresult ;
12211   Dali::BaseHandle *arg1 = 0 ;
12212   Dali::BaseHandle *arg2 = 0 ;
12213   bool result;
12214
12215   arg1 = (Dali::BaseHandle *)jarg1;
12216   if (!arg1) {
12217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
12218     return 0;
12219   }
12220   arg2 = (Dali::BaseHandle *)jarg2;
12221   if (!arg2) {
12222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
12223     return 0;
12224   }
12225   {
12226     try {
12227       result = (bool)Dali::operator <((Dali::BaseHandle const &)*arg1,(Dali::BaseHandle const &)*arg2);
12228     } CALL_CATCH_EXCEPTION(0);
12229   }
12230
12231   jresult = result;
12232   return jresult;
12233 }
12234
12235
12236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTrackerInterface(void * jarg1) {
12237   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
12238
12239   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
12240   {
12241     try {
12242       delete arg1;
12243     } CALL_CATCH_EXCEPTION();
12244   }
12245
12246 }
12247
12248
12249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
12250   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
12251   SlotObserver *arg2 = (SlotObserver *) 0 ;
12252   CallbackBase *arg3 = (CallbackBase *) 0 ;
12253
12254   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
12255   arg2 = (SlotObserver *)jarg2;
12256   arg3 = (CallbackBase *)jarg3;
12257   {
12258     try {
12259       (arg1)->SignalConnected(arg2,arg3);
12260     } CALL_CATCH_EXCEPTION();
12261   }
12262
12263 }
12264
12265
12266 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalObserver(void * jarg1) {
12267   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
12268
12269   arg1 = (Dali::SignalObserver *)jarg1;
12270   {
12271     try {
12272       delete arg1;
12273     } CALL_CATCH_EXCEPTION();
12274   }
12275
12276 }
12277
12278
12279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SignalObserver_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
12280   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
12281   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
12282   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
12283
12284   arg1 = (Dali::SignalObserver *)jarg1;
12285   arg2 = (Dali::SlotObserver *)jarg2;
12286   arg3 = (Dali::CallbackBase *)jarg3;
12287   {
12288     try {
12289       (arg1)->SignalDisconnected(arg2,arg3);
12290     } CALL_CATCH_EXCEPTION();
12291   }
12292
12293 }
12294
12295
12296 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SlotObserver(void * jarg1) {
12297   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
12298
12299   arg1 = (Dali::SlotObserver *)jarg1;
12300   {
12301     try {
12302       delete arg1;
12303     } CALL_CATCH_EXCEPTION();
12304   }
12305
12306 }
12307
12308
12309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SlotObserver_SlotDisconnected(void * jarg1, void * jarg2) {
12310   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
12311   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
12312
12313   arg1 = (Dali::SlotObserver *)jarg1;
12314   arg2 = (Dali::CallbackBase *)jarg2;
12315   {
12316     try {
12317       (arg1)->SlotDisconnected(arg2);
12318     } CALL_CATCH_EXCEPTION();
12319   }
12320
12321 }
12322
12323
12324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTracker(void * jarg1) {
12325   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
12326
12327   arg1 = (Dali::ConnectionTracker *)jarg1;
12328   {
12329     try {
12330       delete arg1;
12331     } CALL_CATCH_EXCEPTION();
12332   }
12333
12334 }
12335
12336
12337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_DisconnectAll(void * jarg1) {
12338   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
12339
12340   arg1 = (Dali::ConnectionTracker *)jarg1;
12341   {
12342     try {
12343       (arg1)->DisconnectAll();
12344     } CALL_CATCH_EXCEPTION();
12345   }
12346
12347 }
12348
12349
12350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
12351   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
12352   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
12353   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
12354
12355   arg1 = (Dali::ConnectionTracker *)jarg1;
12356   arg2 = (Dali::SlotObserver *)jarg2;
12357   arg3 = (Dali::CallbackBase *)jarg3;
12358   {
12359     try {
12360       (arg1)->SignalConnected(arg2,arg3);
12361     } CALL_CATCH_EXCEPTION();
12362   }
12363
12364 }
12365
12366
12367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
12368   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
12369   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
12370   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
12371
12372   arg1 = (Dali::ConnectionTracker *)jarg1;
12373   arg2 = (Dali::SlotObserver *)jarg2;
12374   arg3 = (Dali::CallbackBase *)jarg3;
12375   {
12376     try {
12377       (arg1)->SignalDisconnected(arg2,arg3);
12378     } CALL_CATCH_EXCEPTION();
12379   }
12380
12381 }
12382
12383
12384 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ConnectionTracker_GetConnectionCount(void * jarg1) {
12385   unsigned long jresult ;
12386   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
12387   std::size_t result;
12388
12389   arg1 = (Dali::ConnectionTracker *)jarg1;
12390   {
12391     try {
12392       result = ((Dali::ConnectionTracker const *)arg1)->GetConnectionCount();
12393     } CALL_CATCH_EXCEPTION(0);
12394   }
12395
12396   jresult = (unsigned long)result;
12397   return jresult;
12398 }
12399
12400
12401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_0() {
12402   void * jresult ;
12403   Dali::ObjectRegistry *result = 0 ;
12404
12405   {
12406     try {
12407       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry();
12408     } CALL_CATCH_EXCEPTION(0);
12409   }
12410
12411   jresult = (void *)result;
12412   return jresult;
12413 }
12414
12415
12416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectRegistry(void * jarg1) {
12417   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
12418
12419   arg1 = (Dali::ObjectRegistry *)jarg1;
12420   {
12421     try {
12422       delete arg1;
12423     } CALL_CATCH_EXCEPTION();
12424   }
12425
12426 }
12427
12428
12429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_1(void * jarg1) {
12430   void * jresult ;
12431   Dali::ObjectRegistry *arg1 = 0 ;
12432   Dali::ObjectRegistry *result = 0 ;
12433
12434   arg1 = (Dali::ObjectRegistry *)jarg1;
12435   if (!arg1) {
12436     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
12437     return 0;
12438   }
12439   {
12440     try {
12441       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry((Dali::ObjectRegistry const &)*arg1);
12442     } CALL_CATCH_EXCEPTION(0);
12443   }
12444
12445   jresult = (void *)result;
12446   return jresult;
12447 }
12448
12449
12450 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_Assign(void * jarg1, void * jarg2) {
12451   void * jresult ;
12452   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
12453   Dali::ObjectRegistry *arg2 = 0 ;
12454   Dali::ObjectRegistry *result = 0 ;
12455
12456   arg1 = (Dali::ObjectRegistry *)jarg1;
12457   arg2 = (Dali::ObjectRegistry *)jarg2;
12458   if (!arg2) {
12459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
12460     return 0;
12461   }
12462   {
12463     try {
12464       result = (Dali::ObjectRegistry *) &(arg1)->operator =((Dali::ObjectRegistry const &)*arg2);
12465     } CALL_CATCH_EXCEPTION(0);
12466   }
12467
12468   jresult = (void *)result;
12469   return jresult;
12470 }
12471
12472
12473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectCreatedSignal(void * jarg1) {
12474   void * jresult ;
12475   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
12476   Dali::ObjectRegistry::ObjectCreatedSignalType *result = 0 ;
12477
12478   arg1 = (Dali::ObjectRegistry *)jarg1;
12479   {
12480     try {
12481       result = (Dali::ObjectRegistry::ObjectCreatedSignalType *) &(arg1)->ObjectCreatedSignal();
12482     } CALL_CATCH_EXCEPTION(0);
12483   }
12484
12485   jresult = (void *)result;
12486   return jresult;
12487 }
12488
12489
12490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectDestroyedSignal(void * jarg1) {
12491   void * jresult ;
12492   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
12493   Dali::ObjectRegistry::ObjectDestroyedSignalType *result = 0 ;
12494
12495   arg1 = (Dali::ObjectRegistry *)jarg1;
12496   {
12497     try {
12498       result = (Dali::ObjectRegistry::ObjectDestroyedSignalType *) &(arg1)->ObjectDestroyedSignal();
12499     } CALL_CATCH_EXCEPTION(0);
12500   }
12501
12502   jresult = (void *)result;
12503   return jresult;
12504 }
12505
12506
12507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_0() {
12508   void * jresult ;
12509   Dali::PropertyCondition *result = 0 ;
12510
12511   {
12512     try {
12513       result = (Dali::PropertyCondition *)new Dali::PropertyCondition();
12514     } CALL_CATCH_EXCEPTION(0);
12515   }
12516
12517   jresult = (void *)result;
12518   return jresult;
12519 }
12520
12521
12522 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyCondition(void * jarg1) {
12523   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
12524
12525   arg1 = (Dali::PropertyCondition *)jarg1;
12526   {
12527     try {
12528       delete arg1;
12529     } CALL_CATCH_EXCEPTION();
12530   }
12531
12532 }
12533
12534
12535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_1(void * jarg1) {
12536   void * jresult ;
12537   Dali::PropertyCondition *arg1 = 0 ;
12538   Dali::PropertyCondition *result = 0 ;
12539
12540   arg1 = (Dali::PropertyCondition *)jarg1;
12541   if (!arg1) {
12542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
12543     return 0;
12544   }
12545   {
12546     try {
12547       result = (Dali::PropertyCondition *)new Dali::PropertyCondition((Dali::PropertyCondition const &)*arg1);
12548     } CALL_CATCH_EXCEPTION(0);
12549   }
12550
12551   jresult = (void *)result;
12552   return jresult;
12553 }
12554
12555
12556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyCondition_Assign(void * jarg1, void * jarg2) {
12557   void * jresult ;
12558   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
12559   Dali::PropertyCondition *arg2 = 0 ;
12560   Dali::PropertyCondition *result = 0 ;
12561
12562   arg1 = (Dali::PropertyCondition *)jarg1;
12563   arg2 = (Dali::PropertyCondition *)jarg2;
12564   if (!arg2) {
12565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
12566     return 0;
12567   }
12568   {
12569     try {
12570       result = (Dali::PropertyCondition *) &(arg1)->operator =((Dali::PropertyCondition const &)*arg2);
12571     } CALL_CATCH_EXCEPTION(0);
12572   }
12573
12574   jresult = (void *)result;
12575   return jresult;
12576 }
12577
12578
12579 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgumentCount(void * jarg1) {
12580   unsigned long jresult ;
12581   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
12582   std::size_t result;
12583
12584   arg1 = (Dali::PropertyCondition *)jarg1;
12585   {
12586     try {
12587       result = ((Dali::PropertyCondition const *)arg1)->GetArgumentCount();
12588     } CALL_CATCH_EXCEPTION(0);
12589   }
12590   jresult = (unsigned long)result;
12591   return jresult;
12592 }
12593
12594
12595 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgument(void * jarg1, unsigned long jarg2) {
12596   float jresult ;
12597   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
12598   std::size_t arg2 ;
12599   float result;
12600
12601   arg1 = (Dali::PropertyCondition *)jarg1;
12602   arg2 = (std::size_t)jarg2;
12603   {
12604     try {
12605       result = (float)((Dali::PropertyCondition const *)arg1)->GetArgument(arg2);
12606     } CALL_CATCH_EXCEPTION(0);
12607   }
12608   jresult = result;
12609   return jresult;
12610 }
12611
12612
12613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LessThanCondition(float jarg1) {
12614   void * jresult ;
12615   float arg1 ;
12616   Dali::PropertyCondition result;
12617
12618   arg1 = (float)jarg1;
12619   {
12620     try {
12621       result = Dali::LessThanCondition(arg1);
12622     } CALL_CATCH_EXCEPTION(0);
12623   }
12624
12625   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
12626   return jresult;
12627 }
12628
12629
12630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GreaterThanCondition(float jarg1) {
12631   void * jresult ;
12632   float arg1 ;
12633   Dali::PropertyCondition result;
12634
12635   arg1 = (float)jarg1;
12636   {
12637     try {
12638       result = Dali::GreaterThanCondition(arg1);
12639     } CALL_CATCH_EXCEPTION(0);
12640   }
12641
12642   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
12643   return jresult;
12644 }
12645
12646
12647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InsideCondition(float jarg1, float jarg2) {
12648   void * jresult ;
12649   float arg1 ;
12650   float arg2 ;
12651   Dali::PropertyCondition result;
12652
12653   arg1 = (float)jarg1;
12654   arg2 = (float)jarg2;
12655   {
12656     try {
12657       result = Dali::InsideCondition(arg1,arg2);
12658     } CALL_CATCH_EXCEPTION(0);
12659   }
12660
12661   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
12662   return jresult;
12663 }
12664
12665
12666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OutsideCondition(float jarg1, float jarg2) {
12667   void * jresult ;
12668   float arg1 ;
12669   float arg2 ;
12670   Dali::PropertyCondition result;
12671
12672   arg1 = (float)jarg1;
12673   arg2 = (float)jarg2;
12674   {
12675     try {
12676       result = Dali::OutsideCondition(arg1,arg2);
12677     } CALL_CATCH_EXCEPTION(0);
12678   }
12679
12680   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
12681   return jresult;
12682 }
12683
12684
12685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_0(float jarg1, float jarg2) {
12686   void * jresult ;
12687   float arg1 ;
12688   float arg2 ;
12689   Dali::PropertyCondition result;
12690
12691   arg1 = (float)jarg1;
12692   arg2 = (float)jarg2;
12693   {
12694     try {
12695       result = Dali::StepCondition(arg1,arg2);
12696     } CALL_CATCH_EXCEPTION(0);
12697   }
12698
12699   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
12700   return jresult;
12701 }
12702
12703
12704 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_1(float jarg1) {
12705   void * jresult ;
12706   float arg1 ;
12707   Dali::PropertyCondition result;
12708
12709   arg1 = (float)jarg1;
12710   {
12711     try {
12712       result = Dali::StepCondition(arg1);
12713     } CALL_CATCH_EXCEPTION(0);
12714   }
12715
12716   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
12717   return jresult;
12718 }
12719
12720
12721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VariableStepCondition(void * jarg1) {
12722   void * jresult ;
12723   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg1 = 0 ;
12724   Dali::PropertyCondition result;
12725
12726   arg1 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg1;
12727   if (!arg1) {
12728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
12729     return 0;
12730   }
12731   {
12732     try {
12733       result = Dali::VariableStepCondition((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg1);
12734     } CALL_CATCH_EXCEPTION(0);
12735   }
12736
12737   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
12738   return jresult;
12739 }
12740
12741
12742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_0() {
12743   void * jresult ;
12744   Dali::PropertyNotification *result = 0 ;
12745
12746   {
12747     try {
12748       result = (Dali::PropertyNotification *)new Dali::PropertyNotification();
12749     } CALL_CATCH_EXCEPTION(0);
12750   }
12751
12752   jresult = (void *)result;
12753   return jresult;
12754 }
12755
12756
12757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_DownCast(void * jarg1) {
12758   void * jresult ;
12759   Dali::BaseHandle arg1 ;
12760   Dali::BaseHandle *argp1 ;
12761   Dali::PropertyNotification result;
12762
12763   argp1 = (Dali::BaseHandle *)jarg1;
12764   if (!argp1) {
12765     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
12766     return 0;
12767   }
12768   arg1 = *argp1;
12769   {
12770     try {
12771       result = Dali::PropertyNotification::DownCast(arg1);
12772     } CALL_CATCH_EXCEPTION(0);
12773   }
12774
12775   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
12776   return jresult;
12777 }
12778
12779
12780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotification(void * jarg1) {
12781   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
12782
12783   arg1 = (Dali::PropertyNotification *)jarg1;
12784   {
12785     try {
12786       delete arg1;
12787     } CALL_CATCH_EXCEPTION();
12788   }
12789
12790 }
12791
12792
12793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_1(void * jarg1) {
12794   void * jresult ;
12795   Dali::PropertyNotification *arg1 = 0 ;
12796   Dali::PropertyNotification *result = 0 ;
12797
12798   arg1 = (Dali::PropertyNotification *)jarg1;
12799   if (!arg1) {
12800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
12801     return 0;
12802   }
12803   {
12804     try {
12805       result = (Dali::PropertyNotification *)new Dali::PropertyNotification((Dali::PropertyNotification const &)*arg1);
12806     } CALL_CATCH_EXCEPTION(0);
12807   }
12808
12809   jresult = (void *)result;
12810   return jresult;
12811 }
12812
12813
12814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_Assign(void * jarg1, void * jarg2) {
12815   void * jresult ;
12816   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
12817   Dali::PropertyNotification *arg2 = 0 ;
12818   Dali::PropertyNotification *result = 0 ;
12819
12820   arg1 = (Dali::PropertyNotification *)jarg1;
12821   arg2 = (Dali::PropertyNotification *)jarg2;
12822   if (!arg2) {
12823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
12824     return 0;
12825   }
12826   {
12827     try {
12828       result = (Dali::PropertyNotification *) &(arg1)->operator =((Dali::PropertyNotification const &)*arg2);
12829     } CALL_CATCH_EXCEPTION(0);
12830   }
12831
12832   jresult = (void *)result;
12833   return jresult;
12834 }
12835
12836
12837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetCondition__SWIG_0(void * jarg1) {
12838   void * jresult ;
12839   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
12840   Dali::PropertyCondition result;
12841
12842   arg1 = (Dali::PropertyNotification *)jarg1;
12843   {
12844     try {
12845       result = (arg1)->GetCondition();
12846     } CALL_CATCH_EXCEPTION(0);
12847   }
12848
12849   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
12850   return jresult;
12851 }
12852
12853
12854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTarget(void * jarg1) {
12855   void * jresult ;
12856   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
12857   Dali::Handle result;
12858
12859   arg1 = (Dali::PropertyNotification *)jarg1;
12860   {
12861     try {
12862       result = ((Dali::PropertyNotification const *)arg1)->GetTarget();
12863     } CALL_CATCH_EXCEPTION(0);
12864   }
12865
12866   jresult = new Dali::Handle((const Dali::Handle &)result);
12867   return jresult;
12868 }
12869
12870
12871 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTargetProperty(void * jarg1) {
12872   int jresult ;
12873   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
12874   Dali::Property::Index result;
12875
12876   arg1 = (Dali::PropertyNotification *)jarg1;
12877   {
12878     try {
12879       result = (Dali::Property::Index)((Dali::PropertyNotification const *)arg1)->GetTargetProperty();
12880     } CALL_CATCH_EXCEPTION(0);
12881   }
12882
12883   jresult = result;
12884   return jresult;
12885 }
12886
12887
12888 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotification_SetNotifyMode(void * jarg1, int jarg2) {
12889   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
12890   Dali::PropertyNotification::NotifyMode arg2 ;
12891
12892   arg1 = (Dali::PropertyNotification *)jarg1;
12893   arg2 = (Dali::PropertyNotification::NotifyMode)jarg2;
12894   {
12895     try {
12896       (arg1)->SetNotifyMode(arg2);
12897     } CALL_CATCH_EXCEPTION();
12898   }
12899
12900 }
12901
12902
12903 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyMode(void * jarg1) {
12904   int jresult ;
12905   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
12906   Dali::PropertyNotification::NotifyMode result;
12907
12908   arg1 = (Dali::PropertyNotification *)jarg1;
12909   {
12910     try {
12911       result = (Dali::PropertyNotification::NotifyMode)(arg1)->GetNotifyMode();
12912     } CALL_CATCH_EXCEPTION(0);
12913   }
12914
12915   jresult = (int)result;
12916   return jresult;
12917 }
12918
12919
12920 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyResult(void * jarg1) {
12921   unsigned int jresult ;
12922   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
12923   bool result;
12924
12925   arg1 = (Dali::PropertyNotification *)jarg1;
12926   {
12927     try {
12928       result = (bool)((Dali::PropertyNotification const *)arg1)->GetNotifyResult();
12929     } CALL_CATCH_EXCEPTION(0);
12930   }
12931
12932   jresult = result;
12933   return jresult;
12934 }
12935
12936
12937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_NotifySignal(void * jarg1) {
12938   void * jresult ;
12939   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
12940   Dali::PropertyNotifySignalType *result = 0 ;
12941
12942   arg1 = (Dali::PropertyNotification *)jarg1;
12943   {
12944     try {
12945       result = (Dali::PropertyNotifySignalType *) &(arg1)->NotifySignal();
12946     } CALL_CATCH_EXCEPTION(0);
12947   }
12948
12949   jresult = (void *)result;
12950   return jresult;
12951 }
12952
12953
12954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_0() {
12955   void * jresult ;
12956   Dali::Handle *result = 0 ;
12957
12958   {
12959     try {
12960       result = (Dali::Handle *)new Dali::Handle();
12961     } CALL_CATCH_EXCEPTION(0);
12962   }
12963
12964   jresult = (void *)result;
12965   return jresult;
12966 }
12967
12968
12969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_New() {
12970   void * jresult ;
12971   Dali::Handle result;
12972
12973   {
12974     try {
12975       result = Dali::Handle::New();
12976     } CALL_CATCH_EXCEPTION(0);
12977   }
12978
12979   jresult = new Dali::Handle((const Dali::Handle &)result);
12980   return jresult;
12981 }
12982
12983
12984 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Handle(void * jarg1) {
12985   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
12986
12987   arg1 = (Dali::Handle *)jarg1;
12988   {
12989     try {
12990       delete arg1;
12991     } CALL_CATCH_EXCEPTION();
12992   }
12993
12994 }
12995
12996
12997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_1(void * jarg1) {
12998   void * jresult ;
12999   Dali::Handle *arg1 = 0 ;
13000   Dali::Handle *result = 0 ;
13001
13002   arg1 = (Dali::Handle *)jarg1;
13003   if (!arg1) {
13004     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
13005     return 0;
13006   }
13007   {
13008     try {
13009       result = (Dali::Handle *)new Dali::Handle((Dali::Handle const &)*arg1);
13010     } CALL_CATCH_EXCEPTION(0);
13011   }
13012
13013   jresult = (void *)result;
13014   return jresult;
13015 }
13016
13017
13018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_Assign(void * jarg1, void * jarg2) {
13019   void * jresult ;
13020   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13021   Dali::Handle *arg2 = 0 ;
13022   Dali::Handle *result = 0 ;
13023
13024   arg1 = (Dali::Handle *)jarg1;
13025   arg2 = (Dali::Handle *)jarg2;
13026   if (!arg2) {
13027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
13028     return 0;
13029   }
13030   {
13031     try {
13032       result = (Dali::Handle *) &(arg1)->operator =((Dali::Handle const &)*arg2);
13033     } CALL_CATCH_EXCEPTION(0);
13034   }
13035
13036   jresult = (void *)result;
13037   return jresult;
13038 }
13039
13040
13041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_DownCast(void * jarg1) {
13042   void * jresult ;
13043   Dali::BaseHandle arg1 ;
13044   Dali::BaseHandle *argp1 ;
13045   Dali::Handle result;
13046
13047   argp1 = (Dali::BaseHandle *)jarg1;
13048   if (!argp1) {
13049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
13050     return 0;
13051   }
13052   arg1 = *argp1;
13053   {
13054     try {
13055       result = Dali::Handle::DownCast(arg1);
13056     } CALL_CATCH_EXCEPTION(0);
13057   }
13058
13059   jresult = new Dali::Handle((const Dali::Handle &)result);
13060   return jresult;
13061 }
13062
13063
13064 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_Supports(void * jarg1, int jarg2) {
13065   unsigned int jresult ;
13066   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13067   Dali::Handle::Capability arg2 ;
13068   bool result;
13069
13070   arg1 = (Dali::Handle *)jarg1;
13071   arg2 = (Dali::Handle::Capability)jarg2;
13072   {
13073     try {
13074       result = (bool)((Dali::Handle const *)arg1)->Supports(arg2);
13075     } CALL_CATCH_EXCEPTION(0);
13076   }
13077
13078   jresult = result;
13079   return jresult;
13080 }
13081
13082
13083 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyCount(void * jarg1) {
13084   unsigned int jresult ;
13085   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13086   unsigned int result;
13087
13088   arg1 = (Dali::Handle *)jarg1;
13089   {
13090     try {
13091       result = (unsigned int)((Dali::Handle const *)arg1)->GetPropertyCount();
13092     } CALL_CATCH_EXCEPTION(0);
13093   }
13094
13095   jresult = result;
13096   return jresult;
13097 }
13098
13099
13100 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Handle_GetPropertyName(void * jarg1, int jarg2) {
13101   char * jresult ;
13102   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13103   Dali::Property::Index arg2 ;
13104   std::string result;
13105
13106   arg1 = (Dali::Handle *)jarg1;
13107   arg2 = (Dali::Property::Index)jarg2;
13108   {
13109     try {
13110       result = ((Dali::Handle const *)arg1)->GetPropertyName(arg2);
13111     } CALL_CATCH_EXCEPTION(0);
13112   }
13113
13114   jresult = SWIG_csharp_string_callback((&result)->c_str());
13115   return jresult;
13116 }
13117
13118
13119 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndex(void * jarg1, char * jarg2) {
13120   int jresult ;
13121   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13122   std::string *arg2 = 0 ;
13123   Dali::Property::Index result;
13124
13125   arg1 = (Dali::Handle *)jarg1;
13126   if (!jarg2) {
13127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13128     return 0;
13129   }
13130   std::string arg2_str(jarg2);
13131   arg2 = &arg2_str;
13132   {
13133     try {
13134       result = (Dali::Property::Index)((Dali::Handle const *)arg1)->GetPropertyIndex((std::string const &)*arg2);
13135     } CALL_CATCH_EXCEPTION(0);
13136   }
13137
13138   jresult = result;
13139
13140   //argout typemap for const std::string&
13141
13142   return jresult;
13143 }
13144
13145
13146 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyWritable(void * jarg1, int jarg2) {
13147   unsigned int jresult ;
13148   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13149   Dali::Property::Index arg2 ;
13150   bool result;
13151
13152   arg1 = (Dali::Handle *)jarg1;
13153   arg2 = (Dali::Property::Index)jarg2;
13154   {
13155     try {
13156       result = (bool)((Dali::Handle const *)arg1)->IsPropertyWritable(arg2);
13157     } CALL_CATCH_EXCEPTION(0);
13158   }
13159
13160   jresult = result;
13161   return jresult;
13162 }
13163
13164
13165 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAnimatable(void * jarg1, int jarg2) {
13166   unsigned int jresult ;
13167   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13168   Dali::Property::Index arg2 ;
13169   bool result;
13170
13171   arg1 = (Dali::Handle *)jarg1;
13172   arg2 = (Dali::Property::Index)jarg2;
13173   {
13174     try {
13175       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAnimatable(arg2);
13176     } CALL_CATCH_EXCEPTION(0);
13177   }
13178
13179   jresult = result;
13180   return jresult;
13181 }
13182
13183
13184 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAConstraintInput(void * jarg1, int jarg2) {
13185   unsigned int jresult ;
13186   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13187   Dali::Property::Index arg2 ;
13188   bool result;
13189
13190   arg1 = (Dali::Handle *)jarg1;
13191   arg2 = (Dali::Property::Index)jarg2;
13192   {
13193     try {
13194       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAConstraintInput(arg2);
13195     } CALL_CATCH_EXCEPTION(0);
13196   }
13197
13198   jresult = result;
13199   return jresult;
13200 }
13201
13202
13203 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyType(void * jarg1, int jarg2) {
13204   int jresult ;
13205   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13206   Dali::Property::Index arg2 ;
13207   Dali::Property::Type result;
13208
13209   arg1 = (Dali::Handle *)jarg1;
13210   arg2 = (Dali::Property::Index)jarg2;
13211   {
13212     try {
13213       result = (Dali::Property::Type)((Dali::Handle const *)arg1)->GetPropertyType(arg2);
13214     } CALL_CATCH_EXCEPTION(0);
13215   }
13216
13217   jresult = (int)result;
13218   return jresult;
13219 }
13220
13221
13222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_SetProperty(void * jarg1, int jarg2, void * jarg3) {
13223   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13224   Dali::Property::Index arg2 ;
13225   Dali::Property::Value *arg3 = 0 ;
13226
13227   arg1 = (Dali::Handle *)jarg1;
13228   arg2 = (Dali::Property::Index)jarg2;
13229   arg3 = (Dali::Property::Value *)jarg3;
13230   if (!arg3) {
13231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
13232     return ;
13233   }
13234   {
13235     try {
13236       (arg1)->SetProperty(arg2,(Dali::Property::Value const &)*arg3);
13237     } CALL_CATCH_EXCEPTION();
13238   }
13239
13240 }
13241
13242
13243 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
13244   int jresult ;
13245   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13246   std::string *arg2 = 0 ;
13247   Dali::Property::Value *arg3 = 0 ;
13248   Dali::Property::Index result;
13249
13250   arg1 = (Dali::Handle *)jarg1;
13251   if (!jarg2) {
13252     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13253     return 0;
13254   }
13255   std::string arg2_str(jarg2);
13256   arg2 = &arg2_str;
13257   arg3 = (Dali::Property::Value *)jarg3;
13258   if (!arg3) {
13259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
13260     return 0;
13261   }
13262   {
13263     try {
13264       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
13265     } CALL_CATCH_EXCEPTION(0);
13266   }
13267
13268   jresult = result;
13269
13270   //argout typemap for const std::string&
13271
13272   return jresult;
13273 }
13274
13275
13276 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_1(void * jarg1, char * jarg2, void * jarg3, int jarg4) {
13277   int jresult ;
13278   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13279   std::string *arg2 = 0 ;
13280   Dali::Property::Value *arg3 = 0 ;
13281   Dali::Property::AccessMode arg4 ;
13282   Dali::Property::Index result;
13283
13284   arg1 = (Dali::Handle *)jarg1;
13285   if (!jarg2) {
13286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13287     return 0;
13288   }
13289   std::string arg2_str(jarg2);
13290   arg2 = &arg2_str;
13291   arg3 = (Dali::Property::Value *)jarg3;
13292   if (!arg3) {
13293     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
13294     return 0;
13295   }
13296   arg4 = (Dali::Property::AccessMode)jarg4;
13297   {
13298     try {
13299       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3,arg4);
13300     } CALL_CATCH_EXCEPTION(0);
13301   }
13302
13303   jresult = result;
13304
13305   //argout typemap for const std::string&
13306
13307   return jresult;
13308 }
13309
13310
13311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_GetProperty(void * jarg1, int jarg2) {
13312   void * jresult ;
13313   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13314   Dali::Property::Index arg2 ;
13315   Dali::Property::Value result;
13316
13317   arg1 = (Dali::Handle *)jarg1;
13318   arg2 = (Dali::Property::Index)jarg2;
13319   {
13320     try {
13321       result = ((Dali::Handle const *)arg1)->GetProperty(arg2);
13322     } CALL_CATCH_EXCEPTION(0);
13323   }
13324
13325   jresult = new Dali::Property::Value((const Dali::Property::Value &)result);
13326   return jresult;
13327 }
13328
13329
13330 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndices(void * jarg1, void * jarg2) {
13331   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13332   Dali::Property::IndexContainer *arg2 = 0 ;
13333
13334   arg1 = (Dali::Handle *)jarg1;
13335   arg2 = (Dali::Property::IndexContainer *)jarg2;
13336   if (!arg2) {
13337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
13338     return ;
13339   }
13340   {
13341     try {
13342       ((Dali::Handle const *)arg1)->GetPropertyIndices(*arg2);
13343     } CALL_CATCH_EXCEPTION();
13344   }
13345
13346 }
13347
13348
13349 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_0(void * jarg1, int jarg2, void * jarg3) {
13350   void * jresult ;
13351   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13352   Dali::Property::Index arg2 ;
13353   Dali::PropertyCondition *arg3 = 0 ;
13354   Dali::PropertyNotification result;
13355
13356   arg1 = (Dali::Handle *)jarg1;
13357   arg2 = (Dali::Property::Index)jarg2;
13358   arg3 = (Dali::PropertyCondition *)jarg3;
13359   if (!arg3) {
13360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
13361     return 0;
13362   }
13363   {
13364     try {
13365       result = (arg1)->AddPropertyNotification(arg2,(Dali::PropertyCondition const &)*arg3);
13366     } CALL_CATCH_EXCEPTION(0);
13367   }
13368
13369   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
13370   return jresult;
13371 }
13372
13373
13374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_1(void * jarg1, int jarg2, int jarg3, void * jarg4) {
13375   void * jresult ;
13376   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13377   Dali::Property::Index arg2 ;
13378   int arg3 ;
13379   Dali::PropertyCondition *arg4 = 0 ;
13380   Dali::PropertyNotification result;
13381
13382   arg1 = (Dali::Handle *)jarg1;
13383   arg2 = (Dali::Property::Index)jarg2;
13384   arg3 = (int)jarg3;
13385   arg4 = (Dali::PropertyCondition *)jarg4;
13386   if (!arg4) {
13387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
13388     return 0;
13389   }
13390   {
13391     try {
13392       result = (arg1)->AddPropertyNotification(arg2,arg3,(Dali::PropertyCondition const &)*arg4);
13393     } CALL_CATCH_EXCEPTION(0);
13394   }
13395
13396   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
13397   return jresult;
13398 }
13399
13400
13401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotification(void * jarg1, void * jarg2) {
13402   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13403   Dali::PropertyNotification arg2 ;
13404   Dali::PropertyNotification *argp2 ;
13405
13406   arg1 = (Dali::Handle *)jarg1;
13407   argp2 = (Dali::PropertyNotification *)jarg2;
13408   if (!argp2) {
13409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PropertyNotification", 0);
13410     return ;
13411   }
13412   arg2 = *argp2;
13413   {
13414     try {
13415       (arg1)->RemovePropertyNotification(arg2);
13416     } CALL_CATCH_EXCEPTION();
13417   }
13418
13419 }
13420
13421
13422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotifications(void * jarg1) {
13423   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13424
13425   arg1 = (Dali::Handle *)jarg1;
13426   {
13427     try {
13428       (arg1)->RemovePropertyNotifications();
13429     } CALL_CATCH_EXCEPTION();
13430   }
13431
13432 }
13433
13434
13435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_0(void * jarg1) {
13436   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13437
13438   arg1 = (Dali::Handle *)jarg1;
13439   {
13440     try {
13441       (arg1)->RemoveConstraints();
13442     } CALL_CATCH_EXCEPTION();
13443   }
13444
13445 }
13446
13447
13448 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_1(void * jarg1, unsigned int jarg2) {
13449   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13450   unsigned int arg2 ;
13451
13452   arg1 = (Dali::Handle *)jarg1;
13453   arg2 = (unsigned int)jarg2;
13454   {
13455     try {
13456       (arg1)->RemoveConstraints(arg2);
13457     } CALL_CATCH_EXCEPTION();
13458   }
13459
13460 }
13461
13462
13463 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WEIGHT_get() {
13464   int jresult ;
13465   Dali::Property::Index result;
13466
13467   result = (Dali::Property::Index)(Dali::Property::Index)Dali::WeightObject::WEIGHT;
13468   jresult = result;
13469   return jresult;
13470 }
13471
13472
13473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_New() {
13474   void * jresult ;
13475   Dali::Handle result;
13476
13477   {
13478     try {
13479       result = Dali::WeightObject::New();
13480     } CALL_CATCH_EXCEPTION(0);
13481   }
13482
13483   jresult = new Dali::Handle((const Dali::Handle &)result);
13484   return jresult;
13485 }
13486
13487
13488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_0() {
13489   void * jresult ;
13490   Dali::TypeInfo *result = 0 ;
13491
13492   {
13493     try {
13494       result = (Dali::TypeInfo *)new Dali::TypeInfo();
13495     } CALL_CATCH_EXCEPTION(0);
13496   }
13497
13498   jresult = (void *)result;
13499   return jresult;
13500 }
13501
13502
13503 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeInfo(void * jarg1) {
13504   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13505
13506   arg1 = (Dali::TypeInfo *)jarg1;
13507   {
13508     try {
13509       delete arg1;
13510     } CALL_CATCH_EXCEPTION();
13511   }
13512
13513 }
13514
13515
13516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_1(void * jarg1) {
13517   void * jresult ;
13518   Dali::TypeInfo *arg1 = 0 ;
13519   Dali::TypeInfo *result = 0 ;
13520
13521   arg1 = (Dali::TypeInfo *)jarg1;
13522   if (!arg1) {
13523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
13524     return 0;
13525   }
13526   {
13527     try {
13528       result = (Dali::TypeInfo *)new Dali::TypeInfo((Dali::TypeInfo const &)*arg1);
13529     } CALL_CATCH_EXCEPTION(0);
13530   }
13531
13532   jresult = (void *)result;
13533   return jresult;
13534 }
13535
13536
13537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_Assign(void * jarg1, void * jarg2) {
13538   void * jresult ;
13539   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13540   Dali::TypeInfo *arg2 = 0 ;
13541   Dali::TypeInfo *result = 0 ;
13542
13543   arg1 = (Dali::TypeInfo *)jarg1;
13544   arg2 = (Dali::TypeInfo *)jarg2;
13545   if (!arg2) {
13546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
13547     return 0;
13548   }
13549   {
13550     try {
13551       result = (Dali::TypeInfo *) &(arg1)->operator =((Dali::TypeInfo const &)*arg2);
13552     } CALL_CATCH_EXCEPTION(0);
13553   }
13554
13555   jresult = (void *)result;
13556   return jresult;
13557 }
13558
13559
13560 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetName(void * jarg1) {
13561   char * jresult ;
13562   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13563   std::string *result = 0 ;
13564
13565   arg1 = (Dali::TypeInfo *)jarg1;
13566   {
13567     try {
13568       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetName();
13569     } CALL_CATCH_EXCEPTION(0);
13570   }
13571
13572   jresult = SWIG_csharp_string_callback(result->c_str());
13573   return jresult;
13574 }
13575
13576
13577 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetBaseName(void * jarg1) {
13578   char * jresult ;
13579   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13580   std::string *result = 0 ;
13581
13582   arg1 = (Dali::TypeInfo *)jarg1;
13583   {
13584     try {
13585       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetBaseName();
13586     } CALL_CATCH_EXCEPTION(0);
13587   }
13588
13589   jresult = SWIG_csharp_string_callback(result->c_str());
13590   return jresult;
13591 }
13592
13593
13594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_CreateInstance(void * jarg1) {
13595   void * jresult ;
13596   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13597   Dali::BaseHandle result;
13598
13599   arg1 = (Dali::TypeInfo *)jarg1;
13600   {
13601     try {
13602       result = ((Dali::TypeInfo const *)arg1)->CreateInstance();
13603     } CALL_CATCH_EXCEPTION(0);
13604   }
13605
13606   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
13607   return jresult;
13608 }
13609
13610
13611 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionCount(void * jarg1) {
13612   unsigned long jresult ;
13613   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13614   size_t result;
13615
13616   arg1 = (Dali::TypeInfo *)jarg1;
13617   {
13618     try {
13619       result = ((Dali::TypeInfo const *)arg1)->GetActionCount();
13620     } CALL_CATCH_EXCEPTION(0);
13621   }
13622
13623   jresult = (unsigned long)result;
13624   return jresult;
13625 }
13626
13627
13628 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionName(void * jarg1, unsigned long jarg2) {
13629   char * jresult ;
13630   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13631   size_t arg2 ;
13632   std::string result;
13633
13634   arg1 = (Dali::TypeInfo *)jarg1;
13635   arg2 = (size_t)jarg2;
13636   {
13637     try {
13638       result = (arg1)->GetActionName(arg2);
13639     } CALL_CATCH_EXCEPTION(0);
13640   }
13641
13642   jresult = SWIG_csharp_string_callback((&result)->c_str());
13643   return jresult;
13644 }
13645
13646
13647 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalCount(void * jarg1) {
13648   unsigned long jresult ;
13649   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13650   size_t result;
13651
13652   arg1 = (Dali::TypeInfo *)jarg1;
13653   {
13654     try {
13655       result = ((Dali::TypeInfo const *)arg1)->GetSignalCount();
13656     } CALL_CATCH_EXCEPTION(0);
13657   }
13658
13659   jresult = (unsigned long)result;
13660   return jresult;
13661 }
13662
13663
13664 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalName(void * jarg1, unsigned long jarg2) {
13665   char * jresult ;
13666   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13667   size_t arg2 ;
13668   std::string result;
13669
13670   arg1 = (Dali::TypeInfo *)jarg1;
13671   arg2 = (size_t)jarg2;
13672   {
13673     try {
13674       result = (arg1)->GetSignalName(arg2);
13675     } CALL_CATCH_EXCEPTION(0);
13676   }
13677
13678   jresult = SWIG_csharp_string_callback((&result)->c_str());
13679   return jresult;
13680 }
13681
13682
13683 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyCount(void * jarg1) {
13684   unsigned long jresult ;
13685   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13686   size_t result;
13687
13688   arg1 = (Dali::TypeInfo *)jarg1;
13689   {
13690     try {
13691       result = ((Dali::TypeInfo const *)arg1)->GetPropertyCount();
13692     } CALL_CATCH_EXCEPTION(0);
13693   }
13694
13695   jresult = (unsigned long)result;
13696   return jresult;
13697 }
13698
13699
13700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyIndices(void * jarg1, void * jarg2) {
13701   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13702   Dali::Property::IndexContainer *arg2 = 0 ;
13703
13704   arg1 = (Dali::TypeInfo *)jarg1;
13705   arg2 = (Dali::Property::IndexContainer *)jarg2;
13706   if (!arg2) {
13707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
13708     return ;
13709   }
13710   {
13711     try {
13712       ((Dali::TypeInfo const *)arg1)->GetPropertyIndices(*arg2);
13713     } CALL_CATCH_EXCEPTION();
13714   }
13715
13716 }
13717
13718
13719 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyName(void * jarg1, int jarg2) {
13720   char * jresult ;
13721   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13722   Dali::Property::Index arg2 ;
13723   std::string *result = 0 ;
13724
13725   arg1 = (Dali::TypeInfo *)jarg1;
13726   arg2 = (Dali::Property::Index)jarg2;
13727   {
13728     try {
13729       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetPropertyName(arg2);
13730     } CALL_CATCH_EXCEPTION(0);
13731   }
13732
13733   jresult = SWIG_csharp_string_callback(result->c_str());
13734   return jresult;
13735 }
13736
13737
13738 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Get() {
13739   void * jresult ;
13740   Dali::TypeRegistry result;
13741
13742   {
13743     try {
13744       result = Dali::TypeRegistry::Get();
13745     } CALL_CATCH_EXCEPTION(0);
13746   }
13747
13748   jresult = new Dali::TypeRegistry((const Dali::TypeRegistry &)result);
13749   return jresult;
13750 }
13751
13752
13753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_0() {
13754   void * jresult ;
13755   Dali::TypeRegistry *result = 0 ;
13756
13757   {
13758     try {
13759       result = (Dali::TypeRegistry *)new Dali::TypeRegistry();
13760     } CALL_CATCH_EXCEPTION(0);
13761   }
13762
13763   jresult = (void *)result;
13764   return jresult;
13765 }
13766
13767
13768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistry(void * jarg1) {
13769   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
13770
13771   arg1 = (Dali::TypeRegistry *)jarg1;
13772   {
13773     try {
13774       delete arg1;
13775     } CALL_CATCH_EXCEPTION();
13776   }
13777
13778 }
13779
13780
13781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_1(void * jarg1) {
13782   void * jresult ;
13783   Dali::TypeRegistry *arg1 = 0 ;
13784   Dali::TypeRegistry *result = 0 ;
13785
13786   arg1 = (Dali::TypeRegistry *)jarg1;
13787   if (!arg1) {
13788     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
13789     return 0;
13790   }
13791   {
13792     try {
13793       result = (Dali::TypeRegistry *)new Dali::TypeRegistry((Dali::TypeRegistry const &)*arg1);
13794     } CALL_CATCH_EXCEPTION(0);
13795   }
13796
13797   jresult = (void *)result;
13798   return jresult;
13799 }
13800
13801
13802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Assign(void * jarg1, void * jarg2) {
13803   void * jresult ;
13804   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
13805   Dali::TypeRegistry *arg2 = 0 ;
13806   Dali::TypeRegistry *result = 0 ;
13807
13808   arg1 = (Dali::TypeRegistry *)jarg1;
13809   arg2 = (Dali::TypeRegistry *)jarg2;
13810   if (!arg2) {
13811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
13812     return 0;
13813   }
13814   {
13815     try {
13816       result = (Dali::TypeRegistry *) &(arg1)->operator =((Dali::TypeRegistry const &)*arg2);
13817     } CALL_CATCH_EXCEPTION(0);
13818   }
13819
13820   jresult = (void *)result;
13821   return jresult;
13822 }
13823
13824
13825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_0(void * jarg1, char * jarg2) {
13826   void * jresult ;
13827   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
13828   std::string *arg2 = 0 ;
13829   Dali::TypeInfo result;
13830
13831   arg1 = (Dali::TypeRegistry *)jarg1;
13832   if (!jarg2) {
13833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13834     return 0;
13835   }
13836   std::string arg2_str(jarg2);
13837   arg2 = &arg2_str;
13838   {
13839     try {
13840       result = (arg1)->GetTypeInfo((std::string const &)*arg2);
13841     } CALL_CATCH_EXCEPTION(0);
13842   }
13843
13844   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
13845
13846   //argout typemap for const std::string&
13847
13848   return jresult;
13849 }
13850
13851
13852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_1(void * jarg1, void * jarg2) {
13853   void * jresult ;
13854   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
13855   std::type_info *arg2 = 0 ;
13856   Dali::TypeInfo result;
13857
13858   arg1 = (Dali::TypeRegistry *)jarg1;
13859   arg2 = (std::type_info *)jarg2;
13860   if (!arg2) {
13861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
13862     return 0;
13863   }
13864   {
13865     try {
13866       result = (arg1)->GetTypeInfo((std::type_info const &)*arg2);
13867     } CALL_CATCH_EXCEPTION(0);
13868   }
13869
13870   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
13871   return jresult;
13872 }
13873
13874
13875 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeNameCount(void * jarg1) {
13876   unsigned long jresult ;
13877   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
13878   size_t result;
13879
13880   arg1 = (Dali::TypeRegistry *)jarg1;
13881   {
13882     try {
13883       result = ((Dali::TypeRegistry const *)arg1)->GetTypeNameCount();
13884     } CALL_CATCH_EXCEPTION(0);
13885   }
13886
13887   jresult = (unsigned long)result;
13888   return jresult;
13889 }
13890
13891
13892 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeName(void * jarg1, unsigned long jarg2) {
13893   char * jresult ;
13894   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
13895   size_t arg2 ;
13896   std::string result;
13897
13898   arg1 = (Dali::TypeRegistry *)jarg1;
13899   arg2 = (size_t)jarg2;
13900   {
13901     try {
13902       result = ((Dali::TypeRegistry const *)arg1)->GetTypeName(arg2);
13903     } CALL_CATCH_EXCEPTION(0);
13904   }
13905
13906   jresult = SWIG_csharp_string_callback((&result)->c_str());
13907   return jresult;
13908 }
13909
13910
13911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
13912   void * jresult ;
13913   std::type_info *arg1 = 0 ;
13914   std::type_info *arg2 = 0 ;
13915   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
13916   Dali::TypeRegistration *result = 0 ;
13917
13918   arg1 = (std::type_info *)jarg1;
13919   if (!arg1) {
13920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
13921     return 0;
13922   }
13923   arg2 = (std::type_info *)jarg2;
13924   if (!arg2) {
13925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
13926     return 0;
13927   }
13928   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
13929   {
13930     try {
13931       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3);
13932     } CALL_CATCH_EXCEPTION(0);
13933   }
13934
13935   jresult = (void *)result;
13936   return jresult;
13937 }
13938
13939
13940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_1(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
13941   void * jresult ;
13942   std::type_info *arg1 = 0 ;
13943   std::type_info *arg2 = 0 ;
13944   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
13945   bool arg4 ;
13946   Dali::TypeRegistration *result = 0 ;
13947
13948   arg1 = (std::type_info *)jarg1;
13949   if (!arg1) {
13950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
13951     return 0;
13952   }
13953   arg2 = (std::type_info *)jarg2;
13954   if (!arg2) {
13955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
13956     return 0;
13957   }
13958   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
13959   arg4 = jarg4 ? true : false;
13960   {
13961     try {
13962       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3,arg4);
13963     } CALL_CATCH_EXCEPTION(0);
13964   }
13965
13966   jresult = (void *)result;
13967   return jresult;
13968 }
13969
13970
13971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_2(char * jarg1, void * jarg2, void * jarg3) {
13972   void * jresult ;
13973   std::string *arg1 = 0 ;
13974   std::type_info *arg2 = 0 ;
13975   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
13976   Dali::TypeRegistration *result = 0 ;
13977
13978   if (!jarg1) {
13979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13980     return 0;
13981   }
13982   std::string arg1_str(jarg1);
13983   arg1 = &arg1_str;
13984   arg2 = (std::type_info *)jarg2;
13985   if (!arg2) {
13986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
13987     return 0;
13988   }
13989   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
13990   {
13991     try {
13992       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
13993     } CALL_CATCH_EXCEPTION(0);
13994   }
13995
13996   jresult = (void *)result;
13997
13998   //argout typemap for const std::string&
13999
14000   return jresult;
14001 }
14002
14003
14004 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisteredName(void * jarg1) {
14005   char * jresult ;
14006   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
14007   std::string result;
14008
14009   arg1 = (Dali::TypeRegistration *)jarg1;
14010   {
14011     try {
14012       result = ((Dali::TypeRegistration const *)arg1)->RegisteredName();
14013     } CALL_CATCH_EXCEPTION(0);
14014   }
14015
14016   jresult = SWIG_csharp_string_callback((&result)->c_str());
14017   return jresult;
14018 }
14019
14020
14021 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterControl(char * jarg1, void * jarg2) {
14022   std::string *arg1 = 0 ;
14023   Dali::CSharpTypeInfo::CreateFunction arg2 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
14024
14025   if (!jarg1) {
14026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14027     return ;
14028   }
14029   std::string arg1_str(jarg1);
14030   arg1 = &arg1_str;
14031   arg2 = (Dali::CSharpTypeInfo::CreateFunction)jarg2;
14032   {
14033     try {
14034       Dali_TypeRegistration_RegisterControl((std::string const &)*arg1,arg2);
14035     } CALL_CATCH_EXCEPTION();
14036   }
14037
14038
14039   //argout typemap for const std::string&
14040
14041 }
14042
14043
14044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
14045   std::string *arg1 = 0 ;
14046   std::string *arg2 = 0 ;
14047   int arg3 ;
14048   Dali::Property::Type arg4 ;
14049   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
14050   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
14051
14052   if (!jarg1) {
14053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14054     return ;
14055   }
14056   std::string arg1_str(jarg1);
14057   arg1 = &arg1_str;
14058   if (!jarg2) {
14059     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14060     return ;
14061   }
14062   std::string arg2_str(jarg2);
14063   arg2 = &arg2_str;
14064   arg3 = (int)jarg3;
14065   arg4 = (Dali::Property::Type)jarg4;
14066   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
14067   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
14068   {
14069     try {
14070       Dali_TypeRegistration_RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
14071     } CALL_CATCH_EXCEPTION();
14072   }
14073
14074
14075   //argout typemap for const std::string&
14076
14077
14078   //argout typemap for const std::string&
14079
14080 }
14081
14082
14083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistration(void * jarg1) {
14084   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
14085
14086   arg1 = (Dali::TypeRegistration *)jarg1;
14087   {
14088     try {
14089       delete arg1;
14090     } CALL_CATCH_EXCEPTION();
14091   }
14092
14093 }
14094
14095
14096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SignalConnectorType(void * jarg1, char * jarg2, void * jarg3) {
14097   void * jresult ;
14098   Dali::TypeRegistration *arg1 = 0 ;
14099   std::string *arg2 = 0 ;
14100   Dali::TypeInfo::SignalConnectorFunction arg3 = (Dali::TypeInfo::SignalConnectorFunction) 0 ;
14101   Dali::SignalConnectorType *result = 0 ;
14102
14103   arg1 = (Dali::TypeRegistration *)jarg1;
14104   if (!arg1) {
14105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
14106     return 0;
14107   }
14108   if (!jarg2) {
14109     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14110     return 0;
14111   }
14112   std::string arg2_str(jarg2);
14113   arg2 = &arg2_str;
14114   arg3 = (Dali::TypeInfo::SignalConnectorFunction)jarg3;
14115   {
14116     try {
14117       result = (Dali::SignalConnectorType *)new Dali::SignalConnectorType(*arg1,(std::string const &)*arg2,arg3);
14118     } CALL_CATCH_EXCEPTION(0);
14119   }
14120
14121   jresult = (void *)result;
14122
14123   //argout typemap for const std::string&
14124
14125   return jresult;
14126 }
14127
14128
14129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalConnectorType(void * jarg1) {
14130   Dali::SignalConnectorType *arg1 = (Dali::SignalConnectorType *) 0 ;
14131
14132   arg1 = (Dali::SignalConnectorType *)jarg1;
14133   {
14134     try {
14135       delete arg1;
14136     } CALL_CATCH_EXCEPTION();
14137   }
14138
14139 }
14140
14141
14142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeAction(void * jarg1, char * jarg2, void * jarg3) {
14143   void * jresult ;
14144   Dali::TypeRegistration *arg1 = 0 ;
14145   std::string *arg2 = 0 ;
14146   Dali::TypeInfo::ActionFunction arg3 = (Dali::TypeInfo::ActionFunction) 0 ;
14147   Dali::TypeAction *result = 0 ;
14148
14149   arg1 = (Dali::TypeRegistration *)jarg1;
14150   if (!arg1) {
14151     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
14152     return 0;
14153   }
14154   if (!jarg2) {
14155     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14156     return 0;
14157   }
14158   std::string arg2_str(jarg2);
14159   arg2 = &arg2_str;
14160   arg3 = (Dali::TypeInfo::ActionFunction)jarg3;
14161   {
14162     try {
14163       result = (Dali::TypeAction *)new Dali::TypeAction(*arg1,(std::string const &)*arg2,arg3);
14164     } CALL_CATCH_EXCEPTION(0);
14165   }
14166
14167   jresult = (void *)result;
14168
14169   //argout typemap for const std::string&
14170
14171   return jresult;
14172 }
14173
14174
14175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeAction(void * jarg1) {
14176   Dali::TypeAction *arg1 = (Dali::TypeAction *) 0 ;
14177
14178   arg1 = (Dali::TypeAction *)jarg1;
14179   {
14180     try {
14181       delete arg1;
14182     } CALL_CATCH_EXCEPTION();
14183   }
14184
14185 }
14186
14187
14188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
14189   void * jresult ;
14190   Dali::TypeRegistration *arg1 = 0 ;
14191   std::string *arg2 = 0 ;
14192   Dali::Property::Index arg3 ;
14193   Dali::Property::Type arg4 ;
14194   Dali::TypeInfo::SetPropertyFunction arg5 = (Dali::TypeInfo::SetPropertyFunction) 0 ;
14195   Dali::TypeInfo::GetPropertyFunction arg6 = (Dali::TypeInfo::GetPropertyFunction) 0 ;
14196   Dali::PropertyRegistration *result = 0 ;
14197
14198   arg1 = (Dali::TypeRegistration *)jarg1;
14199   if (!arg1) {
14200     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
14201     return 0;
14202   }
14203   if (!jarg2) {
14204     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14205     return 0;
14206   }
14207   std::string arg2_str(jarg2);
14208   arg2 = &arg2_str;
14209   arg3 = (Dali::Property::Index)jarg3;
14210   arg4 = (Dali::Property::Type)jarg4;
14211   arg5 = (Dali::TypeInfo::SetPropertyFunction)jarg5;
14212   arg6 = (Dali::TypeInfo::GetPropertyFunction)jarg6;
14213   {
14214     try {
14215       result = (Dali::PropertyRegistration *)new Dali::PropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
14216     } CALL_CATCH_EXCEPTION(0);
14217   }
14218
14219   jresult = (void *)result;
14220
14221   //argout typemap for const std::string&
14222
14223   return jresult;
14224 }
14225
14226
14227 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyRegistration(void * jarg1) {
14228   Dali::PropertyRegistration *arg1 = (Dali::PropertyRegistration *) 0 ;
14229
14230   arg1 = (Dali::PropertyRegistration *)jarg1;
14231   {
14232     try {
14233       delete arg1;
14234     } CALL_CATCH_EXCEPTION();
14235   }
14236
14237 }
14238
14239
14240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_0(void * jarg1, char * jarg2, int jarg3, int jarg4) {
14241   void * jresult ;
14242   Dali::TypeRegistration *arg1 = 0 ;
14243   std::string *arg2 = 0 ;
14244   Dali::Property::Index arg3 ;
14245   Dali::Property::Type arg4 ;
14246   Dali::AnimatablePropertyRegistration *result = 0 ;
14247
14248   arg1 = (Dali::TypeRegistration *)jarg1;
14249   if (!arg1) {
14250     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
14251     return 0;
14252   }
14253   if (!jarg2) {
14254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14255     return 0;
14256   }
14257   std::string arg2_str(jarg2);
14258   arg2 = &arg2_str;
14259   arg3 = (Dali::Property::Index)jarg3;
14260   arg4 = (Dali::Property::Type)jarg4;
14261   {
14262     try {
14263       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
14264     } CALL_CATCH_EXCEPTION(0);
14265   }
14266
14267   jresult = (void *)result;
14268
14269   //argout typemap for const std::string&
14270
14271   return jresult;
14272 }
14273
14274
14275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_1(void * jarg1, char * jarg2, int jarg3, void * jarg4) {
14276   void * jresult ;
14277   Dali::TypeRegistration *arg1 = 0 ;
14278   std::string *arg2 = 0 ;
14279   Dali::Property::Index arg3 ;
14280   Dali::Property::Value *arg4 = 0 ;
14281   Dali::AnimatablePropertyRegistration *result = 0 ;
14282
14283   arg1 = (Dali::TypeRegistration *)jarg1;
14284   if (!arg1) {
14285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
14286     return 0;
14287   }
14288   if (!jarg2) {
14289     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14290     return 0;
14291   }
14292   std::string arg2_str(jarg2);
14293   arg2 = &arg2_str;
14294   arg3 = (Dali::Property::Index)jarg3;
14295   arg4 = (Dali::Property::Value *)jarg4;
14296   if (!arg4) {
14297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14298     return 0;
14299   }
14300   {
14301     try {
14302       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,(Dali::Property::Value const &)*arg4);
14303     } CALL_CATCH_EXCEPTION(0);
14304   }
14305
14306   jresult = (void *)result;
14307
14308   //argout typemap for const std::string&
14309
14310   return jresult;
14311 }
14312
14313
14314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyRegistration(void * jarg1) {
14315   Dali::AnimatablePropertyRegistration *arg1 = (Dali::AnimatablePropertyRegistration *) 0 ;
14316
14317   arg1 = (Dali::AnimatablePropertyRegistration *)jarg1;
14318   {
14319     try {
14320       delete arg1;
14321     } CALL_CATCH_EXCEPTION();
14322   }
14323
14324 }
14325
14326
14327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyComponentRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
14328   void * jresult ;
14329   Dali::TypeRegistration *arg1 = 0 ;
14330   std::string *arg2 = 0 ;
14331   Dali::Property::Index arg3 ;
14332   Dali::Property::Index arg4 ;
14333   unsigned int arg5 ;
14334   Dali::AnimatablePropertyComponentRegistration *result = 0 ;
14335
14336   arg1 = (Dali::TypeRegistration *)jarg1;
14337   if (!arg1) {
14338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
14339     return 0;
14340   }
14341   if (!jarg2) {
14342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14343     return 0;
14344   }
14345   std::string arg2_str(jarg2);
14346   arg2 = &arg2_str;
14347   arg3 = (Dali::Property::Index)jarg3;
14348   arg4 = (Dali::Property::Index)jarg4;
14349   arg5 = (unsigned int)jarg5;
14350   {
14351     try {
14352       result = (Dali::AnimatablePropertyComponentRegistration *)new Dali::AnimatablePropertyComponentRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5);
14353     } CALL_CATCH_EXCEPTION(0);
14354   }
14355
14356   jresult = (void *)result;
14357
14358   //argout typemap for const std::string&
14359
14360   return jresult;
14361 }
14362
14363
14364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyComponentRegistration(void * jarg1) {
14365   Dali::AnimatablePropertyComponentRegistration *arg1 = (Dali::AnimatablePropertyComponentRegistration *) 0 ;
14366
14367   arg1 = (Dali::AnimatablePropertyComponentRegistration *)jarg1;
14368   {
14369     try {
14370       delete arg1;
14371     } CALL_CATCH_EXCEPTION();
14372   }
14373
14374 }
14375
14376
14377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ChildPropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4) {
14378   void * jresult ;
14379   Dali::TypeRegistration *arg1 = 0 ;
14380   std::string *arg2 = 0 ;
14381   Dali::Property::Index arg3 ;
14382   Dali::Property::Type arg4 ;
14383   Dali::ChildPropertyRegistration *result = 0 ;
14384
14385   arg1 = (Dali::TypeRegistration *)jarg1;
14386   if (!arg1) {
14387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
14388     return 0;
14389   }
14390   if (!jarg2) {
14391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14392     return 0;
14393   }
14394   std::string arg2_str(jarg2);
14395   arg2 = &arg2_str;
14396   arg3 = (Dali::Property::Index)jarg3;
14397   arg4 = (Dali::Property::Type)jarg4;
14398   {
14399     try {
14400       result = (Dali::ChildPropertyRegistration *)new Dali::ChildPropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
14401     } CALL_CATCH_EXCEPTION(0);
14402   }
14403
14404   jresult = (void *)result;
14405
14406   //argout typemap for const std::string&
14407
14408   return jresult;
14409 }
14410
14411
14412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ChildPropertyRegistration(void * jarg1) {
14413   Dali::ChildPropertyRegistration *arg1 = (Dali::ChildPropertyRegistration *) 0 ;
14414
14415   arg1 = (Dali::ChildPropertyRegistration *)jarg1;
14416   {
14417     try {
14418       delete arg1;
14419     } CALL_CATCH_EXCEPTION();
14420   }
14421
14422 }
14423
14424
14425 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterType(char * jarg1, void * jarg2, void * jarg3) {
14426   unsigned int jresult ;
14427   std::string *arg1 = 0 ;
14428   std::type_info *arg2 = 0 ;
14429   Dali::CSharpTypeInfo::CreateFunction arg3 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
14430   bool result;
14431
14432   if (!jarg1) {
14433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14434     return 0;
14435   }
14436   std::string arg1_str(jarg1);
14437   arg1 = &arg1_str;
14438   arg2 = (std::type_info *)jarg2;
14439   if (!arg2) {
14440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
14441     return 0;
14442   }
14443   arg3 = (Dali::CSharpTypeInfo::CreateFunction)jarg3;
14444   {
14445     try {
14446       result = (bool)Dali::CSharpTypeRegistry::RegisterType((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
14447     } CALL_CATCH_EXCEPTION(0);
14448   }
14449
14450   jresult = result;
14451
14452   //argout typemap for const std::string&
14453
14454   return jresult;
14455 }
14456
14457
14458 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
14459   unsigned int jresult ;
14460   std::string *arg1 = 0 ;
14461   std::string *arg2 = 0 ;
14462   Dali::Property::Index arg3 ;
14463   Dali::Property::Type arg4 ;
14464   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
14465   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
14466   bool result;
14467
14468   if (!jarg1) {
14469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14470     return 0;
14471   }
14472   std::string arg1_str(jarg1);
14473   arg1 = &arg1_str;
14474   if (!jarg2) {
14475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14476     return 0;
14477   }
14478   std::string arg2_str(jarg2);
14479   arg2 = &arg2_str;
14480   arg3 = (Dali::Property::Index)jarg3;
14481   arg4 = (Dali::Property::Type)jarg4;
14482   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
14483   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
14484   {
14485     try {
14486       result = (bool)Dali::CSharpTypeRegistry::RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
14487     } CALL_CATCH_EXCEPTION(0);
14488   }
14489
14490   jresult = result;
14491
14492   //argout typemap for const std::string&
14493
14494
14495   //argout typemap for const std::string&
14496
14497   return jresult;
14498 }
14499
14500
14501 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginTop_get() {
14502   float jresult ;
14503   float result;
14504
14505   result = (float)(float)Dali::ParentOrigin::TOP;
14506   jresult = result;
14507   return jresult;
14508 }
14509
14510
14511 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginBottom_get() {
14512   float jresult ;
14513   float result;
14514
14515   result = (float)(float)Dali::ParentOrigin::BOTTOM;
14516   jresult = result;
14517   return jresult;
14518 }
14519
14520
14521 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginLeft_get() {
14522   float jresult ;
14523   float result;
14524
14525   result = (float)(float)Dali::ParentOrigin::LEFT;
14526   jresult = result;
14527   return jresult;
14528 }
14529
14530
14531 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginRight_get() {
14532   float jresult ;
14533   float result;
14534
14535   result = (float)(float)Dali::ParentOrigin::RIGHT;
14536   jresult = result;
14537   return jresult;
14538 }
14539
14540
14541 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginMiddle_get() {
14542   float jresult ;
14543   float result;
14544
14545   result = (float)(float)Dali::ParentOrigin::MIDDLE;
14546   jresult = result;
14547   return jresult;
14548 }
14549
14550
14551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopLeft_get() {
14552   void * jresult ;
14553   Dali::Vector3 *result = 0 ;
14554
14555   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_LEFT;
14556   jresult = (void *)result;
14557   return jresult;
14558 }
14559
14560
14561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopCenter_get() {
14562   void * jresult ;
14563   Dali::Vector3 *result = 0 ;
14564
14565   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_CENTER;
14566   jresult = (void *)result;
14567   return jresult;
14568 }
14569
14570
14571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopRight_get() {
14572   void * jresult ;
14573   Dali::Vector3 *result = 0 ;
14574
14575   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_RIGHT;
14576   jresult = (void *)result;
14577   return jresult;
14578 }
14579
14580
14581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterLeft_get() {
14582   void * jresult ;
14583   Dali::Vector3 *result = 0 ;
14584
14585   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_LEFT;
14586   jresult = (void *)result;
14587   return jresult;
14588 }
14589
14590
14591 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenter_get() {
14592   void * jresult ;
14593   Dali::Vector3 *result = 0 ;
14594
14595   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER;
14596   jresult = (void *)result;
14597   return jresult;
14598 }
14599
14600
14601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterRight_get() {
14602   void * jresult ;
14603   Dali::Vector3 *result = 0 ;
14604
14605   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_RIGHT;
14606   jresult = (void *)result;
14607   return jresult;
14608 }
14609
14610
14611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomLeft_get() {
14612   void * jresult ;
14613   Dali::Vector3 *result = 0 ;
14614
14615   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_LEFT;
14616   jresult = (void *)result;
14617   return jresult;
14618 }
14619
14620
14621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomCenter_get() {
14622   void * jresult ;
14623   Dali::Vector3 *result = 0 ;
14624
14625   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_CENTER;
14626   jresult = (void *)result;
14627   return jresult;
14628 }
14629
14630
14631 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomRight_get() {
14632   void * jresult ;
14633   Dali::Vector3 *result = 0 ;
14634
14635   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_RIGHT;
14636   jresult = (void *)result;
14637   return jresult;
14638 }
14639
14640
14641 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointTop_get() {
14642   float jresult ;
14643   float result;
14644
14645   result = (float)(float)Dali::AnchorPoint::TOP;
14646   jresult = result;
14647   return jresult;
14648 }
14649
14650
14651 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointBottom_get() {
14652   float jresult ;
14653   float result;
14654
14655   result = (float)(float)Dali::AnchorPoint::BOTTOM;
14656   jresult = result;
14657   return jresult;
14658 }
14659
14660
14661 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointLeft_get() {
14662   float jresult ;
14663   float result;
14664
14665   result = (float)(float)Dali::AnchorPoint::LEFT;
14666   jresult = result;
14667   return jresult;
14668 }
14669
14670
14671 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointRight_get() {
14672   float jresult ;
14673   float result;
14674
14675   result = (float)(float)Dali::AnchorPoint::RIGHT;
14676   jresult = result;
14677   return jresult;
14678 }
14679
14680
14681 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointMiddle_get() {
14682   float jresult ;
14683   float result;
14684
14685   result = (float)(float)Dali::AnchorPoint::MIDDLE;
14686   jresult = result;
14687   return jresult;
14688 }
14689
14690
14691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopLeft_get() {
14692   void * jresult ;
14693   Dali::Vector3 *result = 0 ;
14694
14695   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_LEFT;
14696   jresult = (void *)result;
14697   return jresult;
14698 }
14699
14700
14701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopCenter_get() {
14702   void * jresult ;
14703   Dali::Vector3 *result = 0 ;
14704
14705   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_CENTER;
14706   jresult = (void *)result;
14707   return jresult;
14708 }
14709
14710
14711 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopRight_get() {
14712   void * jresult ;
14713   Dali::Vector3 *result = 0 ;
14714
14715   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_RIGHT;
14716   jresult = (void *)result;
14717   return jresult;
14718 }
14719
14720
14721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterLeft_get() {
14722   void * jresult ;
14723   Dali::Vector3 *result = 0 ;
14724
14725   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_LEFT;
14726   jresult = (void *)result;
14727   return jresult;
14728 }
14729
14730
14731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenter_get() {
14732   void * jresult ;
14733   Dali::Vector3 *result = 0 ;
14734
14735   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER;
14736   jresult = (void *)result;
14737   return jresult;
14738 }
14739
14740
14741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterRight_get() {
14742   void * jresult ;
14743   Dali::Vector3 *result = 0 ;
14744
14745   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_RIGHT;
14746   jresult = (void *)result;
14747   return jresult;
14748 }
14749
14750
14751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomLeft_get() {
14752   void * jresult ;
14753   Dali::Vector3 *result = 0 ;
14754
14755   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_LEFT;
14756   jresult = (void *)result;
14757   return jresult;
14758 }
14759
14760
14761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomCenter_get() {
14762   void * jresult ;
14763   Dali::Vector3 *result = 0 ;
14764
14765   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_CENTER;
14766   jresult = (void *)result;
14767   return jresult;
14768 }
14769
14770
14771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomRight_get() {
14772   void * jresult ;
14773   Dali::Vector3 *result = 0 ;
14774
14775   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_RIGHT;
14776   jresult = (void *)result;
14777   return jresult;
14778 }
14779
14780
14781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLACK_get() {
14782   void * jresult ;
14783   Dali::Vector4 *result = 0 ;
14784
14785   result = (Dali::Vector4 *)&Dali::Color::BLACK;
14786   jresult = (void *)result;
14787   return jresult;
14788 }
14789
14790
14791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WHITE_get() {
14792   void * jresult ;
14793   Dali::Vector4 *result = 0 ;
14794
14795   result = (Dali::Vector4 *)&Dali::Color::WHITE;
14796   jresult = (void *)result;
14797   return jresult;
14798 }
14799
14800
14801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RED_get() {
14802   void * jresult ;
14803   Dali::Vector4 *result = 0 ;
14804
14805   result = (Dali::Vector4 *)&Dali::Color::RED;
14806   jresult = (void *)result;
14807   return jresult;
14808 }
14809
14810
14811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GREEN_get() {
14812   void * jresult ;
14813   Dali::Vector4 *result = 0 ;
14814
14815   result = (Dali::Vector4 *)&Dali::Color::GREEN;
14816   jresult = (void *)result;
14817   return jresult;
14818 }
14819
14820
14821 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLUE_get() {
14822   void * jresult ;
14823   Dali::Vector4 *result = 0 ;
14824
14825   result = (Dali::Vector4 *)&Dali::Color::BLUE;
14826   jresult = (void *)result;
14827   return jresult;
14828 }
14829
14830
14831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_YELLOW_get() {
14832   void * jresult ;
14833   Dali::Vector4 *result = 0 ;
14834
14835   result = (Dali::Vector4 *)&Dali::Color::YELLOW;
14836   jresult = (void *)result;
14837   return jresult;
14838 }
14839
14840
14841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MAGENTA_get() {
14842   void * jresult ;
14843   Dali::Vector4 *result = 0 ;
14844
14845   result = (Dali::Vector4 *)&Dali::Color::MAGENTA;
14846   jresult = (void *)result;
14847   return jresult;
14848 }
14849
14850
14851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CYAN_get() {
14852   void * jresult ;
14853   Dali::Vector4 *result = 0 ;
14854
14855   result = (Dali::Vector4 *)&Dali::Color::CYAN;
14856   jresult = (void *)result;
14857   return jresult;
14858 }
14859
14860
14861 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TRANSPARENT_get() {
14862   void * jresult ;
14863   Dali::Vector4 *result = 0 ;
14864
14865   result = (Dali::Vector4 *)&Dali::Color::TRANSPARENT;
14866   jresult = (void *)result;
14867   return jresult;
14868 }
14869
14870
14871 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_0_get() {
14872   float jresult ;
14873   float result;
14874
14875   result = (float)(float)Dali::Math::MACHINE_EPSILON_0;
14876   jresult = result;
14877   return jresult;
14878 }
14879
14880
14881 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1_get() {
14882   float jresult ;
14883   float result;
14884
14885   result = (float)(float)Dali::Math::MACHINE_EPSILON_1;
14886   jresult = result;
14887   return jresult;
14888 }
14889
14890
14891 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10_get() {
14892   float jresult ;
14893   float result;
14894
14895   result = (float)(float)Dali::Math::MACHINE_EPSILON_10;
14896   jresult = result;
14897   return jresult;
14898 }
14899
14900
14901 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_100_get() {
14902   float jresult ;
14903   float result;
14904
14905   result = (float)(float)Dali::Math::MACHINE_EPSILON_100;
14906   jresult = result;
14907   return jresult;
14908 }
14909
14910
14911 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1000_get() {
14912   float jresult ;
14913   float result;
14914
14915   result = (float)(float)Dali::Math::MACHINE_EPSILON_1000;
14916   jresult = result;
14917   return jresult;
14918 }
14919
14920
14921 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10000_get() {
14922   float jresult ;
14923   float result;
14924
14925   result = (float)(float)Dali::Math::MACHINE_EPSILON_10000;
14926   jresult = result;
14927   return jresult;
14928 }
14929
14930
14931 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_get() {
14932   float jresult ;
14933   float result;
14934
14935   result = (float)(float)Dali::Math::PI;
14936   jresult = result;
14937   return jresult;
14938 }
14939
14940
14941 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_2_get() {
14942   float jresult ;
14943   float result;
14944
14945   result = (float)(float)Dali::Math::PI_2;
14946   jresult = result;
14947   return jresult;
14948 }
14949
14950
14951 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_4_get() {
14952   float jresult ;
14953   float result;
14954
14955   result = (float)(float)Dali::Math::PI_4;
14956   jresult = result;
14957   return jresult;
14958 }
14959
14960
14961 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_OVER_180_get() {
14962   float jresult ;
14963   float result;
14964
14965   result = (float)(float)Dali::Math::PI_OVER_180;
14966   jresult = result;
14967   return jresult;
14968 }
14969
14970
14971 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ONE80_OVER_PI_get() {
14972   float jresult ;
14973   float result;
14974
14975   result = (float)(float)Dali::Math::ONE80_OVER_PI;
14976   jresult = result;
14977   return jresult;
14978 }
14979
14980
14981 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResizePolicyDefault_get() {
14982   int jresult ;
14983   Dali::ResizePolicy::Type result;
14984
14985   result = (Dali::ResizePolicy::Type)(Dali::ResizePolicy::Type)Dali::ResizePolicy::DEFAULT;
14986   jresult = (int)result;
14987   return jresult;
14988 }
14989
14990
14991 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Count(void * jarg1) {
14992   unsigned long jresult ;
14993   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
14994   Dali::VectorBase::SizeType result;
14995
14996   arg1 = (Dali::VectorBase *)jarg1;
14997   {
14998     try {
14999       result = ((Dali::VectorBase const *)arg1)->Count();
15000     } CALL_CATCH_EXCEPTION(0);
15001   }
15002
15003   jresult = (unsigned long)result;
15004   return jresult;
15005 }
15006
15007
15008 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Size(void * jarg1) {
15009   unsigned long jresult ;
15010   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
15011   Dali::VectorBase::SizeType result;
15012
15013   arg1 = (Dali::VectorBase *)jarg1;
15014   {
15015     try {
15016       result = ((Dali::VectorBase const *)arg1)->Size();
15017     } CALL_CATCH_EXCEPTION(0);
15018   }
15019
15020   jresult = (unsigned long)result;
15021   return jresult;
15022 }
15023
15024
15025 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VectorBase_Empty(void * jarg1) {
15026   unsigned int jresult ;
15027   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
15028   bool result;
15029
15030   arg1 = (Dali::VectorBase *)jarg1;
15031   {
15032     try {
15033       result = (bool)((Dali::VectorBase const *)arg1)->Empty();
15034     } CALL_CATCH_EXCEPTION(0);
15035   }
15036
15037   jresult = result;
15038   return jresult;
15039 }
15040
15041
15042 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Capacity(void * jarg1) {
15043   unsigned long jresult ;
15044   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
15045   Dali::VectorBase::SizeType result;
15046
15047   arg1 = (Dali::VectorBase *)jarg1;
15048   {
15049     try {
15050       result = ((Dali::VectorBase const *)arg1)->Capacity();
15051     } CALL_CATCH_EXCEPTION(0);
15052   }
15053
15054   jresult = (unsigned long)result;
15055   return jresult;
15056 }
15057
15058
15059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBase_Release(void * jarg1) {
15060   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
15061
15062   arg1 = (Dali::VectorBase *)jarg1;
15063   {
15064     try {
15065       (arg1)->Release();
15066     } CALL_CATCH_EXCEPTION();
15067   }
15068
15069 }
15070
15071
15072 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FIRST_VALID_PIXEL_FORMAT_get() {
15073   int jresult ;
15074   Dali::Pixel::Format result;
15075
15076   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::FIRST_VALID_PIXEL_FORMAT;
15077   jresult = (int)result;
15078   return jresult;
15079 }
15080
15081
15082 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LAST_VALID_PIXEL_FORMAT_get() {
15083   int jresult ;
15084   Dali::Pixel::Format result;
15085
15086   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::LAST_VALID_PIXEL_FORMAT;
15087   jresult = (int)result;
15088   return jresult;
15089 }
15090
15091
15092 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_HasAlpha(int jarg1) {
15093   unsigned int jresult ;
15094   Dali::Pixel::Format arg1 ;
15095   bool result;
15096
15097   arg1 = (Dali::Pixel::Format)jarg1;
15098   {
15099     try {
15100       result = (bool)Dali::Pixel::HasAlpha(arg1);
15101     } CALL_CATCH_EXCEPTION(0);
15102   }
15103
15104   jresult = result;
15105   return jresult;
15106 }
15107
15108
15109 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetBytesPerPixel(int jarg1) {
15110   unsigned int jresult ;
15111   Dali::Pixel::Format arg1 ;
15112   unsigned int result;
15113
15114   arg1 = (Dali::Pixel::Format)jarg1;
15115   {
15116     try {
15117       result = (unsigned int)Dali::Pixel::GetBytesPerPixel(arg1);
15118     } CALL_CATCH_EXCEPTION(0);
15119   }
15120
15121   jresult = result;
15122   return jresult;
15123 }
15124
15125
15126 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GetAlphaOffsetAndMask(int jarg1, void * jarg2, void * jarg3) {
15127   Dali::Pixel::Format arg1 ;
15128   int *arg2 = 0 ;
15129   int *arg3 = 0 ;
15130
15131   arg1 = (Dali::Pixel::Format)jarg1;
15132   arg2 = (int *)jarg2;
15133   if (!arg2) {
15134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
15135     return ;
15136   }
15137   arg3 = (int *)jarg3;
15138   if (!arg3) {
15139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
15140     return ;
15141   }
15142   {
15143     try {
15144       Dali::Pixel::GetAlphaOffsetAndMask(arg1,*arg2,*arg3);
15145     } CALL_CATCH_EXCEPTION();
15146   }
15147
15148 }
15149
15150
15151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_New(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5, int jarg6) {
15152   void * jresult ;
15153   unsigned char *arg1 = (unsigned char *) 0 ;
15154   unsigned int arg2 ;
15155   unsigned int arg3 ;
15156   unsigned int arg4 ;
15157   Dali::Pixel::Format arg5 ;
15158   Dali::PixelData::ReleaseFunction arg6 ;
15159   Dali::PixelData result;
15160
15161   arg1 = jarg1;
15162   arg2 = (unsigned int)jarg2;
15163   arg3 = (unsigned int)jarg3;
15164   arg4 = (unsigned int)jarg4;
15165   arg5 = (Dali::Pixel::Format)jarg5;
15166   arg6 = (Dali::PixelData::ReleaseFunction)jarg6;
15167   {
15168     try {
15169       auto pixelBuffer = new unsigned char[jarg2];
15170       memcpy( pixelBuffer, arg1, arg2);
15171       result = Dali::PixelData::New(pixelBuffer,arg2,arg3,arg4,arg5,arg6);
15172     } CALL_CATCH_EXCEPTION(0);
15173   }
15174
15175   jresult = new Dali::PixelData((const Dali::PixelData &)result);
15176
15177
15178   return jresult;
15179 }
15180
15181
15182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_0() {
15183   void * jresult ;
15184   Dali::PixelData *result = 0 ;
15185
15186   {
15187     try {
15188       result = (Dali::PixelData *)new Dali::PixelData();
15189     } CALL_CATCH_EXCEPTION(0);
15190   }
15191
15192   jresult = (void *)result;
15193   return jresult;
15194 }
15195
15196
15197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelData(void * jarg1) {
15198   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
15199
15200   arg1 = (Dali::PixelData *)jarg1;
15201   {
15202     try {
15203       delete arg1;
15204     } CALL_CATCH_EXCEPTION();
15205   }
15206
15207 }
15208
15209
15210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_1(void * jarg1) {
15211   void * jresult ;
15212   Dali::PixelData *arg1 = 0 ;
15213   Dali::PixelData *result = 0 ;
15214
15215   arg1 = (Dali::PixelData *)jarg1;
15216   if (!arg1) {
15217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
15218     return 0;
15219   }
15220   {
15221     try {
15222       result = (Dali::PixelData *)new Dali::PixelData((Dali::PixelData const &)*arg1);
15223     } CALL_CATCH_EXCEPTION(0);
15224   }
15225
15226   jresult = (void *)result;
15227   return jresult;
15228 }
15229
15230
15231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_Assign(void * jarg1, void * jarg2) {
15232   void * jresult ;
15233   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
15234   Dali::PixelData *arg2 = 0 ;
15235   Dali::PixelData *result = 0 ;
15236
15237   arg1 = (Dali::PixelData *)jarg1;
15238   arg2 = (Dali::PixelData *)jarg2;
15239   if (!arg2) {
15240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
15241     return 0;
15242   }
15243   {
15244     try {
15245       result = (Dali::PixelData *) &(arg1)->operator =((Dali::PixelData const &)*arg2);
15246     } CALL_CATCH_EXCEPTION(0);
15247   }
15248
15249   jresult = (void *)result;
15250   return jresult;
15251 }
15252
15253
15254 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetWidth(void * jarg1) {
15255   unsigned int jresult ;
15256   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
15257   unsigned int result;
15258
15259   arg1 = (Dali::PixelData *)jarg1;
15260   {
15261     try {
15262       result = (unsigned int)((Dali::PixelData const *)arg1)->GetWidth();
15263     } CALL_CATCH_EXCEPTION(0);
15264   }
15265
15266   jresult = result;
15267   return jresult;
15268 }
15269
15270
15271 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetHeight(void * jarg1) {
15272   unsigned int jresult ;
15273   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
15274   unsigned int result;
15275
15276   arg1 = (Dali::PixelData *)jarg1;
15277   {
15278     try {
15279       result = (unsigned int)((Dali::PixelData const *)arg1)->GetHeight();
15280     } CALL_CATCH_EXCEPTION(0);
15281   }
15282
15283   jresult = result;
15284   return jresult;
15285 }
15286
15287
15288 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelData_GetPixelFormat(void * jarg1) {
15289   int jresult ;
15290   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
15291   Dali::Pixel::Format result;
15292
15293   arg1 = (Dali::PixelData *)jarg1;
15294   {
15295     try {
15296       result = (Dali::Pixel::Format)((Dali::PixelData const *)arg1)->GetPixelFormat();
15297     } CALL_CATCH_EXCEPTION(0);
15298   }
15299
15300   jresult = (int)result;
15301   return jresult;
15302 }
15303
15304
15305 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_X_get() {
15306   unsigned int jresult ;
15307   unsigned int result;
15308
15309   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_X;
15310   jresult = result;
15311   return jresult;
15312 }
15313
15314
15315 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_X_get() {
15316   unsigned int jresult ;
15317   unsigned int result;
15318
15319   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_X;
15320   jresult = result;
15321   return jresult;
15322 }
15323
15324
15325 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Y_get() {
15326   unsigned int jresult ;
15327   unsigned int result;
15328
15329   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Y;
15330   jresult = result;
15331   return jresult;
15332 }
15333
15334
15335 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Y_get() {
15336   unsigned int jresult ;
15337   unsigned int result;
15338
15339   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Y;
15340   jresult = result;
15341   return jresult;
15342 }
15343
15344
15345 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Z_get() {
15346   unsigned int jresult ;
15347   unsigned int result;
15348
15349   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Z;
15350   jresult = result;
15351   return jresult;
15352 }
15353
15354
15355 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Z_get() {
15356   unsigned int jresult ;
15357   unsigned int result;
15358
15359   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Z;
15360   jresult = result;
15361   return jresult;
15362 }
15363
15364
15365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_0(int jarg1, int jarg2, unsigned int jarg3, unsigned int jarg4) {
15366   void * jresult ;
15367   Dali::TextureType::Type arg1 ;
15368   Dali::Pixel::Format arg2 ;
15369   unsigned int arg3 ;
15370   unsigned int arg4 ;
15371   Dali::Texture result;
15372
15373   arg1 = (Dali::TextureType::Type)jarg1;
15374   arg2 = (Dali::Pixel::Format)jarg2;
15375   arg3 = (unsigned int)jarg3;
15376   arg4 = (unsigned int)jarg4;
15377   {
15378     try {
15379       result = Dali::Texture::New(arg1,arg2,arg3,arg4);
15380     } CALL_CATCH_EXCEPTION(0);
15381   }
15382
15383   jresult = new Dali::Texture((const Dali::Texture &)result);
15384   return jresult;
15385 }
15386
15387
15388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_1(void * jarg1) {
15389   void * jresult ;
15390   NativeImageInterface *arg1 = 0 ;
15391   Dali::Texture result;
15392
15393   arg1 = (NativeImageInterface *)jarg1;
15394   if (!arg1) {
15395     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
15396     return 0;
15397   }
15398   {
15399     try {
15400       result = Dali::Texture::New(*arg1);
15401     } CALL_CATCH_EXCEPTION(0);
15402   }
15403
15404   jresult = new Dali::Texture((const Dali::Texture &)result);
15405   return jresult;
15406 }
15407
15408 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_0() {
15409   void * jresult ;
15410   Dali::Texture *result = 0 ;
15411
15412   {
15413     try {
15414       result = (Dali::Texture *)new Dali::Texture();
15415     } CALL_CATCH_EXCEPTION(0);
15416   }
15417
15418   jresult = (void *)result;
15419   return jresult;
15420 }
15421
15422
15423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Texture(void * jarg1) {
15424   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
15425
15426   arg1 = (Dali::Texture *)jarg1;
15427   {
15428     try {
15429       delete arg1;
15430     } CALL_CATCH_EXCEPTION();
15431   }
15432
15433 }
15434
15435
15436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_1(void * jarg1) {
15437   void * jresult ;
15438   Dali::Texture *arg1 = 0 ;
15439   Dali::Texture *result = 0 ;
15440
15441   arg1 = (Dali::Texture *)jarg1;
15442   if (!arg1) {
15443     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
15444     return 0;
15445   }
15446   {
15447     try {
15448       result = (Dali::Texture *)new Dali::Texture((Dali::Texture const &)*arg1);
15449     } CALL_CATCH_EXCEPTION(0);
15450   }
15451
15452   jresult = (void *)result;
15453   return jresult;
15454 }
15455
15456
15457 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_DownCast(void * jarg1) {
15458   void * jresult ;
15459   Dali::BaseHandle arg1 ;
15460   Dali::BaseHandle *argp1 ;
15461   Dali::Texture result;
15462
15463   argp1 = (Dali::BaseHandle *)jarg1;
15464   if (!argp1) {
15465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
15466     return 0;
15467   }
15468   arg1 = *argp1;
15469   {
15470     try {
15471       result = Dali::Texture::DownCast(arg1);
15472     } CALL_CATCH_EXCEPTION(0);
15473   }
15474
15475   jresult = new Dali::Texture((const Dali::Texture &)result);
15476   return jresult;
15477 }
15478
15479
15480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_Assign(void * jarg1, void * jarg2) {
15481   void * jresult ;
15482   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
15483   Dali::Texture *arg2 = 0 ;
15484   Dali::Texture *result = 0 ;
15485
15486   arg1 = (Dali::Texture *)jarg1;
15487   arg2 = (Dali::Texture *)jarg2;
15488   if (!arg2) {
15489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
15490     return 0;
15491   }
15492   {
15493     try {
15494       result = (Dali::Texture *) &(arg1)->operator =((Dali::Texture const &)*arg2);
15495     } CALL_CATCH_EXCEPTION(0);
15496   }
15497
15498   jresult = (void *)result;
15499   return jresult;
15500 }
15501
15502
15503 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_0(void * jarg1, void * jarg2) {
15504   unsigned int jresult ;
15505   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
15506   Dali::PixelData arg2 ;
15507   Dali::PixelData *argp2 ;
15508   bool result;
15509
15510   arg1 = (Dali::Texture *)jarg1;
15511   argp2 = (Dali::PixelData *)jarg2;
15512   if (!argp2) {
15513     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
15514     return 0;
15515   }
15516   arg2 = *argp2;
15517   {
15518     try {
15519       result = (bool)(arg1)->Upload(arg2);
15520     } CALL_CATCH_EXCEPTION(0);
15521   }
15522
15523   jresult = result;
15524   return jresult;
15525 }
15526
15527
15528 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) {
15529   unsigned int jresult ;
15530   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
15531   Dali::PixelData arg2 ;
15532   unsigned int arg3 ;
15533   unsigned int arg4 ;
15534   unsigned int arg5 ;
15535   unsigned int arg6 ;
15536   unsigned int arg7 ;
15537   unsigned int arg8 ;
15538   Dali::PixelData *argp2 ;
15539   bool result;
15540
15541   arg1 = (Dali::Texture *)jarg1;
15542   argp2 = (Dali::PixelData *)jarg2;
15543   if (!argp2) {
15544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
15545     return 0;
15546   }
15547   arg2 = *argp2;
15548   arg3 = (unsigned int)jarg3;
15549   arg4 = (unsigned int)jarg4;
15550   arg5 = (unsigned int)jarg5;
15551   arg6 = (unsigned int)jarg6;
15552   arg7 = (unsigned int)jarg7;
15553   arg8 = (unsigned int)jarg8;
15554   {
15555     try {
15556       result = (bool)(arg1)->Upload(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
15557     } CALL_CATCH_EXCEPTION(0);
15558   }
15559
15560   jresult = result;
15561   return jresult;
15562 }
15563
15564
15565 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Texture_GenerateMipmaps(void * jarg1) {
15566   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
15567
15568   arg1 = (Dali::Texture *)jarg1;
15569   {
15570     try {
15571       (arg1)->GenerateMipmaps();
15572     } CALL_CATCH_EXCEPTION();
15573   }
15574
15575 }
15576
15577
15578 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetWidth(void * jarg1) {
15579   unsigned int jresult ;
15580   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
15581   unsigned int result;
15582
15583   arg1 = (Dali::Texture *)jarg1;
15584   {
15585     try {
15586       result = (unsigned int)((Dali::Texture const *)arg1)->GetWidth();
15587     } CALL_CATCH_EXCEPTION(0);
15588   }
15589
15590   jresult = result;
15591   return jresult;
15592 }
15593
15594
15595 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetHeight(void * jarg1) {
15596   unsigned int jresult ;
15597   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
15598   unsigned int result;
15599
15600   arg1 = (Dali::Texture *)jarg1;
15601   {
15602     try {
15603       result = (unsigned int)((Dali::Texture const *)arg1)->GetHeight();
15604     } CALL_CATCH_EXCEPTION(0);
15605   }
15606
15607   jresult = result;
15608   return jresult;
15609 }
15610
15611
15612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_New() {
15613   void * jresult ;
15614   Dali::Sampler result;
15615
15616   {
15617     try {
15618       result = Dali::Sampler::New();
15619     } CALL_CATCH_EXCEPTION(0);
15620   }
15621
15622   jresult = new Dali::Sampler((const Dali::Sampler &)result);
15623   return jresult;
15624 }
15625
15626
15627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_0() {
15628   void * jresult ;
15629   Dali::Sampler *result = 0 ;
15630
15631   {
15632     try {
15633       result = (Dali::Sampler *)new Dali::Sampler();
15634     } CALL_CATCH_EXCEPTION(0);
15635   }
15636
15637   jresult = (void *)result;
15638   return jresult;
15639 }
15640
15641
15642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Sampler(void * jarg1) {
15643   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
15644
15645   arg1 = (Dali::Sampler *)jarg1;
15646   {
15647     try {
15648       delete arg1;
15649     } CALL_CATCH_EXCEPTION();
15650   }
15651
15652 }
15653
15654
15655 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_1(void * jarg1) {
15656   void * jresult ;
15657   Dali::Sampler *arg1 = 0 ;
15658   Dali::Sampler *result = 0 ;
15659
15660   arg1 = (Dali::Sampler *)jarg1;
15661   if (!arg1) {
15662     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
15663     return 0;
15664   }
15665   {
15666     try {
15667       result = (Dali::Sampler *)new Dali::Sampler((Dali::Sampler const &)*arg1);
15668     } CALL_CATCH_EXCEPTION(0);
15669   }
15670
15671   jresult = (void *)result;
15672   return jresult;
15673 }
15674
15675
15676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_DownCast(void * jarg1) {
15677   void * jresult ;
15678   Dali::BaseHandle arg1 ;
15679   Dali::BaseHandle *argp1 ;
15680   Dali::Sampler result;
15681
15682   argp1 = (Dali::BaseHandle *)jarg1;
15683   if (!argp1) {
15684     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
15685     return 0;
15686   }
15687   arg1 = *argp1;
15688   {
15689     try {
15690       result = Dali::Sampler::DownCast(arg1);
15691     } CALL_CATCH_EXCEPTION(0);
15692   }
15693
15694   jresult = new Dali::Sampler((const Dali::Sampler &)result);
15695   return jresult;
15696 }
15697
15698
15699 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_Assign(void * jarg1, void * jarg2) {
15700   void * jresult ;
15701   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
15702   Dali::Sampler *arg2 = 0 ;
15703   Dali::Sampler *result = 0 ;
15704
15705   arg1 = (Dali::Sampler *)jarg1;
15706   arg2 = (Dali::Sampler *)jarg2;
15707   if (!arg2) {
15708     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
15709     return 0;
15710   }
15711   {
15712     try {
15713       result = (Dali::Sampler *) &(arg1)->operator =((Dali::Sampler const &)*arg2);
15714     } CALL_CATCH_EXCEPTION(0);
15715   }
15716
15717   jresult = (void *)result;
15718   return jresult;
15719 }
15720
15721
15722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetFilterMode(void * jarg1, int jarg2, int jarg3) {
15723   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
15724   Dali::FilterMode::Type arg2 ;
15725   Dali::FilterMode::Type arg3 ;
15726
15727   arg1 = (Dali::Sampler *)jarg1;
15728   arg2 = (Dali::FilterMode::Type)jarg2;
15729   arg3 = (Dali::FilterMode::Type)jarg3;
15730   {
15731     try {
15732       (arg1)->SetFilterMode(arg2,arg3);
15733     } CALL_CATCH_EXCEPTION();
15734   }
15735
15736 }
15737
15738
15739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_0(void * jarg1, int jarg2, int jarg3) {
15740   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
15741   Dali::WrapMode::Type arg2 ;
15742   Dali::WrapMode::Type arg3 ;
15743
15744   arg1 = (Dali::Sampler *)jarg1;
15745   arg2 = (Dali::WrapMode::Type)jarg2;
15746   arg3 = (Dali::WrapMode::Type)jarg3;
15747   {
15748     try {
15749       (arg1)->SetWrapMode(arg2,arg3);
15750     } CALL_CATCH_EXCEPTION();
15751   }
15752
15753 }
15754
15755
15756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_1(void * jarg1, int jarg2, int jarg3, int jarg4) {
15757   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
15758   Dali::WrapMode::Type arg2 ;
15759   Dali::WrapMode::Type arg3 ;
15760   Dali::WrapMode::Type arg4 ;
15761
15762   arg1 = (Dali::Sampler *)jarg1;
15763   arg2 = (Dali::WrapMode::Type)jarg2;
15764   arg3 = (Dali::WrapMode::Type)jarg3;
15765   arg4 = (Dali::WrapMode::Type)jarg4;
15766   {
15767     try {
15768       (arg1)->SetWrapMode(arg2,arg3,arg4);
15769     } CALL_CATCH_EXCEPTION();
15770   }
15771
15772 }
15773
15774
15775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_New() {
15776   void * jresult ;
15777   Dali::TextureSet result;
15778
15779   {
15780     try {
15781       result = Dali::TextureSet::New();
15782     } CALL_CATCH_EXCEPTION(0);
15783   }
15784
15785   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
15786   return jresult;
15787 }
15788
15789
15790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_0() {
15791   void * jresult ;
15792   Dali::TextureSet *result = 0 ;
15793
15794   {
15795     try {
15796       result = (Dali::TextureSet *)new Dali::TextureSet();
15797     } CALL_CATCH_EXCEPTION(0);
15798   }
15799
15800   jresult = (void *)result;
15801   return jresult;
15802 }
15803
15804
15805 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextureSet(void * jarg1) {
15806   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
15807
15808   arg1 = (Dali::TextureSet *)jarg1;
15809   {
15810     try {
15811       delete arg1;
15812     } CALL_CATCH_EXCEPTION();
15813   }
15814
15815 }
15816
15817
15818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_1(void * jarg1) {
15819   void * jresult ;
15820   Dali::TextureSet *arg1 = 0 ;
15821   Dali::TextureSet *result = 0 ;
15822
15823   arg1 = (Dali::TextureSet *)jarg1;
15824   if (!arg1) {
15825     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
15826     return 0;
15827   }
15828   {
15829     try {
15830       result = (Dali::TextureSet *)new Dali::TextureSet((Dali::TextureSet const &)*arg1);
15831     } CALL_CATCH_EXCEPTION(0);
15832   }
15833
15834   jresult = (void *)result;
15835   return jresult;
15836 }
15837
15838
15839 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_DownCast(void * jarg1) {
15840   void * jresult ;
15841   Dali::BaseHandle arg1 ;
15842   Dali::BaseHandle *argp1 ;
15843   Dali::TextureSet result;
15844
15845   argp1 = (Dali::BaseHandle *)jarg1;
15846   if (!argp1) {
15847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
15848     return 0;
15849   }
15850   arg1 = *argp1;
15851   {
15852     try {
15853       result = Dali::TextureSet::DownCast(arg1);
15854     } CALL_CATCH_EXCEPTION(0);
15855   }
15856
15857   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
15858   return jresult;
15859 }
15860
15861
15862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_Assign(void * jarg1, void * jarg2) {
15863   void * jresult ;
15864   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
15865   Dali::TextureSet *arg2 = 0 ;
15866   Dali::TextureSet *result = 0 ;
15867
15868   arg1 = (Dali::TextureSet *)jarg1;
15869   arg2 = (Dali::TextureSet *)jarg2;
15870   if (!arg2) {
15871     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
15872     return 0;
15873   }
15874   {
15875     try {
15876       result = (Dali::TextureSet *) &(arg1)->operator =((Dali::TextureSet const &)*arg2);
15877     } CALL_CATCH_EXCEPTION(0);
15878   }
15879
15880   jresult = (void *)result;
15881   return jresult;
15882 }
15883
15884
15885 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetTexture(void * jarg1, unsigned long jarg2, void * jarg3) {
15886   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
15887   size_t arg2 ;
15888   Dali::Texture arg3 ;
15889   Dali::Texture *argp3 ;
15890
15891   arg1 = (Dali::TextureSet *)jarg1;
15892   arg2 = (size_t)jarg2;
15893   argp3 = (Dali::Texture *)jarg3;
15894   if (!argp3) {
15895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
15896     return ;
15897   }
15898   arg3 = *argp3;
15899   {
15900     try {
15901       (arg1)->SetTexture(arg2,arg3);
15902     } CALL_CATCH_EXCEPTION();
15903   }
15904
15905 }
15906
15907
15908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetTexture(void * jarg1, unsigned long jarg2) {
15909   void * jresult ;
15910   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
15911   size_t arg2 ;
15912   Dali::Texture result;
15913
15914   arg1 = (Dali::TextureSet *)jarg1;
15915   arg2 = (size_t)jarg2;
15916   {
15917     try {
15918       result = ((Dali::TextureSet const *)arg1)->GetTexture(arg2);
15919     } CALL_CATCH_EXCEPTION(0);
15920   }
15921
15922   jresult = new Dali::Texture((const Dali::Texture &)result);
15923   return jresult;
15924 }
15925
15926
15927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetSampler(void * jarg1, unsigned long jarg2, void * jarg3) {
15928   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
15929   size_t arg2 ;
15930   Dali::Sampler arg3 ;
15931   Dali::Sampler *argp3 ;
15932
15933   arg1 = (Dali::TextureSet *)jarg1;
15934   arg2 = (size_t)jarg2;
15935   argp3 = (Dali::Sampler *)jarg3;
15936   if (!argp3) {
15937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Sampler", 0);
15938     return ;
15939   }
15940   arg3 = *argp3;
15941   {
15942     try {
15943       (arg1)->SetSampler(arg2,arg3);
15944     } CALL_CATCH_EXCEPTION();
15945   }
15946
15947 }
15948
15949
15950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetSampler(void * jarg1, unsigned long jarg2) {
15951   void * jresult ;
15952   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
15953   size_t arg2 ;
15954   Dali::Sampler result;
15955
15956   arg1 = (Dali::TextureSet *)jarg1;
15957   arg2 = (size_t)jarg2;
15958   {
15959     try {
15960       result = ((Dali::TextureSet const *)arg1)->GetSampler(arg2);
15961     } CALL_CATCH_EXCEPTION(0);
15962   }
15963
15964   jresult = new Dali::Sampler((const Dali::Sampler &)result);
15965   return jresult;
15966 }
15967
15968
15969 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextureSet_GetTextureCount(void * jarg1) {
15970   unsigned long jresult ;
15971   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
15972   size_t result;
15973
15974   arg1 = (Dali::TextureSet *)jarg1;
15975   {
15976     try {
15977       result = ((Dali::TextureSet const *)arg1)->GetTextureCount();
15978     } CALL_CATCH_EXCEPTION(0);
15979   }
15980
15981   jresult = (unsigned long)result;
15982   return jresult;
15983 }
15984
15985
15986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VertexBuffer_New(void * jarg1) {
15987   void * jresult ;
15988   Dali::Property::Map *arg1 = 0 ;
15989   Dali::VertexBuffer result;
15990
15991   arg1 = (Dali::Property::Map *)jarg1;
15992   if (!arg1) {
15993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
15994     return 0;
15995   }
15996   {
15997     try {
15998       result = Dali::VertexBuffer::New(*arg1);
15999     } CALL_CATCH_EXCEPTION(0);
16000   }
16001
16002   jresult = new Dali::VertexBuffer((const Dali::VertexBuffer &)result);
16003   return jresult;
16004 }
16005
16006
16007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VertexBuffer__SWIG_0() {
16008   void * jresult ;
16009   Dali::VertexBuffer *result = 0 ;
16010
16011   {
16012     try {
16013       result = (Dali::VertexBuffer *)new Dali::VertexBuffer();
16014     } CALL_CATCH_EXCEPTION(0);
16015   }
16016
16017   jresult = (void *)result;
16018   return jresult;
16019 }
16020
16021
16022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VertexBuffer(void * jarg1) {
16023   Dali::VertexBuffer *arg1 = (Dali::VertexBuffer *) 0 ;
16024
16025   arg1 = (Dali::VertexBuffer *)jarg1;
16026   {
16027     try {
16028       delete arg1;
16029     } CALL_CATCH_EXCEPTION();
16030   }
16031
16032 }
16033
16034
16035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VertexBuffer__SWIG_1(void * jarg1) {
16036   void * jresult ;
16037   Dali::VertexBuffer *arg1 = 0 ;
16038   Dali::VertexBuffer *result = 0 ;
16039
16040   arg1 = (Dali::VertexBuffer *)jarg1;
16041   if (!arg1) {
16042     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::VertexBuffer const & type is null", 0);
16043     return 0;
16044   }
16045   {
16046     try {
16047       result = (Dali::VertexBuffer *)new Dali::VertexBuffer((Dali::VertexBuffer const &)*arg1);
16048     } CALL_CATCH_EXCEPTION(0);
16049   }
16050
16051   jresult = (void *)result;
16052   return jresult;
16053 }
16054
16055
16056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VertexBuffer_DownCast(void * jarg1) {
16057   void * jresult ;
16058   Dali::BaseHandle arg1 ;
16059   Dali::BaseHandle *argp1 ;
16060   Dali::VertexBuffer result;
16061
16062   argp1 = (Dali::BaseHandle *)jarg1;
16063   if (!argp1) {
16064     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
16065     return 0;
16066   }
16067   arg1 = *argp1;
16068   {
16069     try {
16070       result = Dali::VertexBuffer::DownCast(arg1);
16071     } CALL_CATCH_EXCEPTION(0);
16072   }
16073
16074   jresult = new Dali::VertexBuffer((const Dali::VertexBuffer &)result);
16075   return jresult;
16076 }
16077
16078
16079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VertexBuffer_Assign(void * jarg1, void * jarg2) {
16080   void * jresult ;
16081   Dali::VertexBuffer *arg1 = (Dali::VertexBuffer *) 0 ;
16082   Dali::VertexBuffer *arg2 = 0 ;
16083   Dali::VertexBuffer *result = 0 ;
16084
16085   arg1 = (Dali::VertexBuffer *)jarg1;
16086   arg2 = (Dali::VertexBuffer *)jarg2;
16087   if (!arg2) {
16088     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::VertexBuffer const & type is null", 0);
16089     return 0;
16090   }
16091   {
16092     try {
16093       result = (Dali::VertexBuffer *) &(arg1)->operator =((Dali::VertexBuffer const &)*arg2);
16094     } CALL_CATCH_EXCEPTION(0);
16095   }
16096
16097   jresult = (void *)result;
16098   return jresult;
16099 }
16100
16101
16102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VertexBuffer_SetData(void * jarg1, void * jarg2, unsigned long jarg3) {
16103   Dali::VertexBuffer *arg1 = (Dali::VertexBuffer *) 0 ;
16104   void *arg2 = (void *) 0 ;
16105   std::size_t arg3 ;
16106
16107   arg1 = (Dali::VertexBuffer *)jarg1;
16108   arg2 = jarg2;
16109   arg3 = (std::size_t)jarg3;
16110   {
16111     try {
16112       (arg1)->SetData((void const *)arg2,arg3);
16113     } CALL_CATCH_EXCEPTION();
16114   }
16115
16116 }
16117
16118
16119 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VertexBuffer_GetSize(void * jarg1) {
16120   unsigned long jresult ;
16121   Dali::VertexBuffer *arg1 = (Dali::VertexBuffer *) 0 ;
16122   std::size_t result;
16123
16124   arg1 = (Dali::VertexBuffer *)jarg1;
16125   {
16126     try {
16127       result = ((Dali::VertexBuffer const *)arg1)->GetSize();
16128     } CALL_CATCH_EXCEPTION(0);
16129   }
16130
16131   jresult = (unsigned long)result;
16132   return jresult;
16133 }
16134
16135
16136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_New() {
16137   void * jresult ;
16138   Dali::Geometry result;
16139
16140   {
16141     try {
16142       result = Dali::Geometry::New();
16143     } CALL_CATCH_EXCEPTION(0);
16144   }
16145
16146   jresult = new Dali::Geometry((const Dali::Geometry &)result);
16147   return jresult;
16148 }
16149
16150
16151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_0() {
16152   void * jresult ;
16153   Dali::Geometry *result = 0 ;
16154
16155   {
16156     try {
16157       result = (Dali::Geometry *)new Dali::Geometry();
16158     } CALL_CATCH_EXCEPTION(0);
16159   }
16160
16161   jresult = (void *)result;
16162   return jresult;
16163 }
16164
16165
16166 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Geometry(void * jarg1) {
16167   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
16168
16169   arg1 = (Dali::Geometry *)jarg1;
16170   {
16171     try {
16172       delete arg1;
16173     } CALL_CATCH_EXCEPTION();
16174   }
16175
16176 }
16177
16178
16179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_1(void * jarg1) {
16180   void * jresult ;
16181   Dali::Geometry *arg1 = 0 ;
16182   Dali::Geometry *result = 0 ;
16183
16184   arg1 = (Dali::Geometry *)jarg1;
16185   if (!arg1) {
16186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
16187     return 0;
16188   }
16189   {
16190     try {
16191       result = (Dali::Geometry *)new Dali::Geometry((Dali::Geometry const &)*arg1);
16192     } CALL_CATCH_EXCEPTION(0);
16193   }
16194
16195   jresult = (void *)result;
16196   return jresult;
16197 }
16198
16199
16200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_DownCast(void * jarg1) {
16201   void * jresult ;
16202   Dali::BaseHandle arg1 ;
16203   Dali::BaseHandle *argp1 ;
16204   Dali::Geometry result;
16205
16206   argp1 = (Dali::BaseHandle *)jarg1;
16207   if (!argp1) {
16208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
16209     return 0;
16210   }
16211   arg1 = *argp1;
16212   {
16213     try {
16214       result = Dali::Geometry::DownCast(arg1);
16215     } CALL_CATCH_EXCEPTION(0);
16216   }
16217
16218   jresult = new Dali::Geometry((const Dali::Geometry &)result);
16219   return jresult;
16220 }
16221
16222
16223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_Assign(void * jarg1, void * jarg2) {
16224   void * jresult ;
16225   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
16226   Dali::Geometry *arg2 = 0 ;
16227   Dali::Geometry *result = 0 ;
16228
16229   arg1 = (Dali::Geometry *)jarg1;
16230   arg2 = (Dali::Geometry *)jarg2;
16231   if (!arg2) {
16232     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
16233     return 0;
16234   }
16235   {
16236     try {
16237       result = (Dali::Geometry *) &(arg1)->operator =((Dali::Geometry const &)*arg2);
16238     } CALL_CATCH_EXCEPTION(0);
16239   }
16240
16241   jresult = (void *)result;
16242   return jresult;
16243 }
16244
16245
16246 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_AddVertexBuffer(void * jarg1, void * jarg2) {
16247   unsigned long jresult ;
16248   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
16249   Dali::VertexBuffer *arg2 = 0 ;
16250   std::size_t result;
16251
16252   arg1 = (Dali::Geometry *)jarg1;
16253   arg2 = (Dali::VertexBuffer *)jarg2;
16254   if (!arg2) {
16255     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::VertexBuffer & type is null", 0);
16256     return 0;
16257   }
16258   {
16259     try {
16260       result = (arg1)->AddVertexBuffer(*arg2);
16261     } CALL_CATCH_EXCEPTION(0);
16262   }
16263
16264   jresult = (unsigned long)result;
16265   return jresult;
16266 }
16267
16268
16269 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_GetNumberOfVertexBuffers(void * jarg1) {
16270   unsigned long jresult ;
16271   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
16272   std::size_t result;
16273
16274   arg1 = (Dali::Geometry *)jarg1;
16275   {
16276     try {
16277       result = ((Dali::Geometry const *)arg1)->GetNumberOfVertexBuffers();
16278     } CALL_CATCH_EXCEPTION(0);
16279   }
16280
16281   jresult = (unsigned long)result;
16282   return jresult;
16283 }
16284
16285
16286 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_RemoveVertexBuffer(void * jarg1, unsigned long jarg2) {
16287   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
16288   std::size_t arg2 ;
16289
16290   arg1 = (Dali::Geometry *)jarg1;
16291   arg2 = (std::size_t)jarg2;
16292   {
16293     try {
16294       (arg1)->RemoveVertexBuffer(arg2);
16295     } CALL_CATCH_EXCEPTION();
16296   }
16297
16298 }
16299
16300
16301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetIndexBuffer(void * jarg1, unsigned short* jarg2, unsigned long jarg3) {
16302   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
16303   unsigned short *arg2 = (unsigned short *) 0 ;
16304   size_t arg3 ;
16305
16306   arg1 = (Dali::Geometry *)jarg1;
16307   arg2 = jarg2;
16308   arg3 = (size_t)jarg3;
16309   {
16310     try {
16311       (arg1)->SetIndexBuffer((unsigned short const *)arg2,arg3);
16312     } CALL_CATCH_EXCEPTION();
16313   }
16314
16315
16316
16317 }
16318
16319
16320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetType(void * jarg1, int jarg2) {
16321   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
16322   Dali::Geometry::Type arg2 ;
16323
16324   arg1 = (Dali::Geometry *)jarg1;
16325   arg2 = (Dali::Geometry::Type)jarg2;
16326   {
16327     try {
16328       (arg1)->SetType(arg2);
16329     } CALL_CATCH_EXCEPTION();
16330   }
16331
16332 }
16333
16334
16335 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Geometry_GetType(void * jarg1) {
16336   int jresult ;
16337   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
16338   Dali::Geometry::Type result;
16339
16340   arg1 = (Dali::Geometry *)jarg1;
16341   {
16342     try {
16343       result = (Dali::Geometry::Type)((Dali::Geometry const *)arg1)->GetType();
16344     } CALL_CATCH_EXCEPTION(0);
16345   }
16346
16347   jresult = (int)result;
16348   return jresult;
16349 }
16350
16351
16352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Hint() {
16353   void * jresult ;
16354   Dali::Shader::Hint *result = 0 ;
16355
16356   {
16357     try {
16358       result = (Dali::Shader::Hint *)new Dali::Shader::Hint();
16359     } CALL_CATCH_EXCEPTION(0);
16360   }
16361
16362   jresult = (void *)result;
16363   return jresult;
16364 }
16365
16366
16367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Hint(void * jarg1) {
16368   Dali::Shader::Hint *arg1 = (Dali::Shader::Hint *) 0 ;
16369
16370   arg1 = (Dali::Shader::Hint *)jarg1;
16371   {
16372     try {
16373       delete arg1;
16374     } CALL_CATCH_EXCEPTION();
16375   }
16376
16377 }
16378
16379
16380 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shader_Property_PROGRAM_get() {
16381   int jresult ;
16382   int result;
16383
16384   result = (int)Dali::Shader::Property::PROGRAM;
16385   jresult = (int)result;
16386   return jresult;
16387 }
16388
16389
16390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Property() {
16391   void * jresult ;
16392   Dali::Shader::Property *result = 0 ;
16393
16394   {
16395     try {
16396       result = (Dali::Shader::Property *)new Dali::Shader::Property();
16397     } CALL_CATCH_EXCEPTION(0);
16398   }
16399
16400   jresult = (void *)result;
16401   return jresult;
16402 }
16403
16404
16405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Property(void * jarg1) {
16406   Dali::Shader::Property *arg1 = (Dali::Shader::Property *) 0 ;
16407
16408   arg1 = (Dali::Shader::Property *)jarg1;
16409   {
16410     try {
16411       delete arg1;
16412     } CALL_CATCH_EXCEPTION();
16413   }
16414
16415 }
16416
16417
16418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_0(char * jarg1, char * jarg2, int jarg3) {
16419   void * jresult ;
16420   std::string *arg1 = 0 ;
16421   std::string *arg2 = 0 ;
16422   Dali::Shader::Hint::Value arg3 ;
16423   Dali::Shader result;
16424
16425   if (!jarg1) {
16426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16427     return 0;
16428   }
16429   std::string arg1_str(jarg1);
16430   arg1 = &arg1_str;
16431   if (!jarg2) {
16432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16433     return 0;
16434   }
16435   std::string arg2_str(jarg2);
16436   arg2 = &arg2_str;
16437   arg3 = (Dali::Shader::Hint::Value)jarg3;
16438   {
16439     try {
16440       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2,arg3);
16441     } CALL_CATCH_EXCEPTION(0);
16442   }
16443
16444   jresult = new Dali::Shader((const Dali::Shader &)result);
16445
16446   //argout typemap for const std::string&
16447
16448
16449   //argout typemap for const std::string&
16450
16451   return jresult;
16452 }
16453
16454
16455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_1(char * jarg1, char * jarg2) {
16456   void * jresult ;
16457   std::string *arg1 = 0 ;
16458   std::string *arg2 = 0 ;
16459   Dali::Shader result;
16460
16461   if (!jarg1) {
16462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16463     return 0;
16464   }
16465   std::string arg1_str(jarg1);
16466   arg1 = &arg1_str;
16467   if (!jarg2) {
16468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16469     return 0;
16470   }
16471   std::string arg2_str(jarg2);
16472   arg2 = &arg2_str;
16473   {
16474     try {
16475       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2);
16476     } CALL_CATCH_EXCEPTION(0);
16477   }
16478
16479   jresult = new Dali::Shader((const Dali::Shader &)result);
16480
16481   //argout typemap for const std::string&
16482
16483
16484   //argout typemap for const std::string&
16485
16486   return jresult;
16487 }
16488
16489
16490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_0() {
16491   void * jresult ;
16492   Dali::Shader *result = 0 ;
16493
16494   {
16495     try {
16496       result = (Dali::Shader *)new Dali::Shader();
16497     } CALL_CATCH_EXCEPTION(0);
16498   }
16499
16500   jresult = (void *)result;
16501   return jresult;
16502 }
16503
16504
16505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader(void * jarg1) {
16506   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
16507
16508   arg1 = (Dali::Shader *)jarg1;
16509   {
16510     try {
16511       delete arg1;
16512     } CALL_CATCH_EXCEPTION();
16513   }
16514
16515 }
16516
16517
16518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_1(void * jarg1) {
16519   void * jresult ;
16520   Dali::Shader *arg1 = 0 ;
16521   Dali::Shader *result = 0 ;
16522
16523   arg1 = (Dali::Shader *)jarg1;
16524   if (!arg1) {
16525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
16526     return 0;
16527   }
16528   {
16529     try {
16530       result = (Dali::Shader *)new Dali::Shader((Dali::Shader const &)*arg1);
16531     } CALL_CATCH_EXCEPTION(0);
16532   }
16533
16534   jresult = (void *)result;
16535   return jresult;
16536 }
16537
16538
16539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_DownCast(void * jarg1) {
16540   void * jresult ;
16541   Dali::BaseHandle arg1 ;
16542   Dali::BaseHandle *argp1 ;
16543   Dali::Shader result;
16544
16545   argp1 = (Dali::BaseHandle *)jarg1;
16546   if (!argp1) {
16547     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
16548     return 0;
16549   }
16550   arg1 = *argp1;
16551   {
16552     try {
16553       result = Dali::Shader::DownCast(arg1);
16554     } CALL_CATCH_EXCEPTION(0);
16555   }
16556
16557   jresult = new Dali::Shader((const Dali::Shader &)result);
16558   return jresult;
16559 }
16560
16561
16562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_Assign(void * jarg1, void * jarg2) {
16563   void * jresult ;
16564   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
16565   Dali::Shader *arg2 = 0 ;
16566   Dali::Shader *result = 0 ;
16567
16568   arg1 = (Dali::Shader *)jarg1;
16569   arg2 = (Dali::Shader *)jarg2;
16570   if (!arg2) {
16571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
16572     return 0;
16573   }
16574   {
16575     try {
16576       result = (Dali::Shader *) &(arg1)->operator =((Dali::Shader const &)*arg2);
16577     } CALL_CATCH_EXCEPTION(0);
16578   }
16579
16580   jresult = (void *)result;
16581   return jresult;
16582 }
16583
16584
16585 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_BACKGROUND_EFFECT_get() {
16586   int jresult ;
16587   int result;
16588
16589   result = (int)Dali::Toolkit::DepthIndex::Ranges::BACKGROUND_EFFECT;
16590   jresult = (int)result;
16591   return jresult;
16592 }
16593
16594
16595 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_BACKGROUND_get() {
16596   int jresult ;
16597   int result;
16598
16599   result = (int)Dali::Toolkit::DepthIndex::Ranges::BACKGROUND;
16600   jresult = (int)result;
16601   return jresult;
16602 }
16603
16604
16605 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_CONTENT_get() {
16606   int jresult ;
16607   int result;
16608
16609   result = (int)Dali::Toolkit::DepthIndex::Ranges::CONTENT;
16610   jresult = (int)result;
16611   return jresult;
16612 }
16613
16614
16615 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_DECORATION_get() {
16616   int jresult ;
16617   int result;
16618
16619   result = (int)Dali::Toolkit::DepthIndex::Ranges::DECORATION;
16620   jresult = (int)result;
16621   return jresult;
16622 }
16623
16624
16625 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_FOREGROUND_EFFECT_get() {
16626   int jresult ;
16627   int result;
16628
16629   result = (int)Dali::Toolkit::DepthIndex::FOREGROUND_EFFECT;
16630   jresult = (int)result;
16631   return jresult;
16632 }
16633
16634
16635 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_INDEX_get() {
16636   int jresult ;
16637   int result;
16638
16639   result = (int)Dali::Renderer::Property::DEPTH_INDEX;
16640   jresult = (int)result;
16641   return jresult;
16642 }
16643
16644
16645 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_FACE_CULLING_MODE_get() {
16646   int jresult ;
16647   int result;
16648
16649   result = (int)Dali::Renderer::Property::FACE_CULLING_MODE;
16650   jresult = (int)result;
16651   return jresult;
16652 }
16653
16654
16655 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_MODE_get() {
16656   int jresult ;
16657   int result;
16658
16659   result = (int)Dali::Renderer::Property::BLEND_MODE;
16660   jresult = (int)result;
16661   return jresult;
16662 }
16663
16664
16665 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_RGB_get() {
16666   int jresult ;
16667   int result;
16668
16669   result = (int)Dali::Renderer::Property::BLEND_EQUATION_RGB;
16670   jresult = (int)result;
16671   return jresult;
16672 }
16673
16674
16675 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_ALPHA_get() {
16676   int jresult ;
16677   int result;
16678
16679   result = (int)Dali::Renderer::Property::BLEND_EQUATION_ALPHA;
16680   jresult = (int)result;
16681   return jresult;
16682 }
16683
16684
16685 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_RGB_get() {
16686   int jresult ;
16687   int result;
16688
16689   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB;
16690   jresult = (int)result;
16691   return jresult;
16692 }
16693
16694
16695 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_RGB_get() {
16696   int jresult ;
16697   int result;
16698
16699   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB;
16700   jresult = (int)result;
16701   return jresult;
16702 }
16703
16704
16705 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_ALPHA_get() {
16706   int jresult ;
16707   int result;
16708
16709   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA;
16710   jresult = (int)result;
16711   return jresult;
16712 }
16713
16714
16715 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_ALPHA_get() {
16716   int jresult ;
16717   int result;
16718
16719   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA;
16720   jresult = (int)result;
16721   return jresult;
16722 }
16723
16724
16725 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_COLOR_get() {
16726   int jresult ;
16727   int result;
16728
16729   result = (int)Dali::Renderer::Property::BLEND_COLOR;
16730   jresult = (int)result;
16731   return jresult;
16732 }
16733
16734
16735 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_PRE_MULTIPLIED_ALPHA_get() {
16736   int jresult ;
16737   int result;
16738
16739   result = (int)Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA;
16740   jresult = (int)result;
16741   return jresult;
16742 }
16743
16744
16745 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_FIRST_get() {
16746   int jresult ;
16747   int result;
16748
16749   result = (int)Dali::Renderer::Property::INDEX_RANGE_FIRST;
16750   jresult = (int)result;
16751   return jresult;
16752 }
16753
16754
16755 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_COUNT_get() {
16756   int jresult ;
16757   int result;
16758
16759   result = (int)Dali::Renderer::Property::INDEX_RANGE_COUNT;
16760   jresult = (int)result;
16761   return jresult;
16762 }
16763
16764
16765 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_WRITE_MODE_get() {
16766   int jresult ;
16767   int result;
16768
16769   result = (int)Dali::Renderer::Property::DEPTH_WRITE_MODE;
16770   jresult = (int)result;
16771   return jresult;
16772 }
16773
16774
16775 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_FUNCTION_get() {
16776   int jresult ;
16777   int result;
16778
16779   result = (int)Dali::Renderer::Property::DEPTH_FUNCTION;
16780   jresult = (int)result;
16781   return jresult;
16782 }
16783
16784
16785 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_TEST_MODE_get() {
16786   int jresult ;
16787   int result;
16788
16789   result = (int)Dali::Renderer::Property::DEPTH_TEST_MODE;
16790   jresult = (int)result;
16791   return jresult;
16792 }
16793
16794
16795 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_RENDER_MODE_get() {
16796   int jresult ;
16797   int result;
16798
16799   result = (int)Dali::Renderer::Property::RENDER_MODE;
16800   jresult = (int)result;
16801   return jresult;
16802 }
16803
16804
16805 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_get() {
16806   int jresult ;
16807   int result;
16808
16809   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION;
16810   jresult = (int)result;
16811   return jresult;
16812 }
16813
16814
16815 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_MASK_get() {
16816   int jresult ;
16817   int result;
16818
16819   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_MASK;
16820   jresult = (int)result;
16821   return jresult;
16822 }
16823
16824
16825 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_REFERENCE_get() {
16826   int jresult ;
16827   int result;
16828
16829   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE;
16830   jresult = (int)result;
16831   return jresult;
16832 }
16833
16834
16835 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_MASK_get() {
16836   int jresult ;
16837   int result;
16838
16839   result = (int)Dali::Renderer::Property::STENCIL_MASK;
16840   jresult = (int)result;
16841   return jresult;
16842 }
16843
16844
16845 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_FAIL_get() {
16846   int jresult ;
16847   int result;
16848
16849   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL;
16850   jresult = (int)result;
16851   return jresult;
16852 }
16853
16854
16855 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_FAIL_get() {
16856   int jresult ;
16857   int result;
16858
16859   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL;
16860   jresult = (int)result;
16861   return jresult;
16862 }
16863
16864
16865 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_PASS_get() {
16866   int jresult ;
16867   int result;
16868
16869   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS;
16870   jresult = (int)result;
16871   return jresult;
16872 }
16873
16874
16875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer_Property() {
16876   void * jresult ;
16877   Dali::Renderer::Property *result = 0 ;
16878
16879   {
16880     try {
16881       result = (Dali::Renderer::Property *)new Dali::Renderer::Property();
16882     } CALL_CATCH_EXCEPTION(0);
16883   }
16884
16885   jresult = (void *)result;
16886   return jresult;
16887 }
16888
16889
16890 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer_Property(void * jarg1) {
16891   Dali::Renderer::Property *arg1 = (Dali::Renderer::Property *) 0 ;
16892
16893   arg1 = (Dali::Renderer::Property *)jarg1;
16894   {
16895     try {
16896       delete arg1;
16897     } CALL_CATCH_EXCEPTION();
16898   }
16899
16900 }
16901
16902
16903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_New(void * jarg1, void * jarg2) {
16904   void * jresult ;
16905   Dali::Geometry *arg1 = 0 ;
16906   Dali::Shader *arg2 = 0 ;
16907   Dali::Renderer result;
16908
16909   arg1 = (Dali::Geometry *)jarg1;
16910   if (!arg1) {
16911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
16912     return 0;
16913   }
16914   arg2 = (Dali::Shader *)jarg2;
16915   if (!arg2) {
16916     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
16917     return 0;
16918   }
16919   {
16920     try {
16921       result = Dali::Renderer::New(*arg1,*arg2);
16922     } CALL_CATCH_EXCEPTION(0);
16923   }
16924
16925   jresult = new Dali::Renderer((const Dali::Renderer &)result);
16926   return jresult;
16927 }
16928
16929
16930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_0() {
16931   void * jresult ;
16932   Dali::Renderer *result = 0 ;
16933
16934   {
16935     try {
16936       result = (Dali::Renderer *)new Dali::Renderer();
16937     } CALL_CATCH_EXCEPTION(0);
16938   }
16939
16940   jresult = (void *)result;
16941   return jresult;
16942 }
16943
16944
16945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer(void * jarg1) {
16946   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
16947
16948   arg1 = (Dali::Renderer *)jarg1;
16949   {
16950     try {
16951       delete arg1;
16952     } CALL_CATCH_EXCEPTION();
16953   }
16954
16955 }
16956
16957
16958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_1(void * jarg1) {
16959   void * jresult ;
16960   Dali::Renderer *arg1 = 0 ;
16961   Dali::Renderer *result = 0 ;
16962
16963   arg1 = (Dali::Renderer *)jarg1;
16964   if (!arg1) {
16965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
16966     return 0;
16967   }
16968   {
16969     try {
16970       result = (Dali::Renderer *)new Dali::Renderer((Dali::Renderer const &)*arg1);
16971     } CALL_CATCH_EXCEPTION(0);
16972   }
16973
16974   jresult = (void *)result;
16975   return jresult;
16976 }
16977
16978
16979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_DownCast(void * jarg1) {
16980   void * jresult ;
16981   Dali::BaseHandle arg1 ;
16982   Dali::BaseHandle *argp1 ;
16983   Dali::Renderer result;
16984
16985   argp1 = (Dali::BaseHandle *)jarg1;
16986   if (!argp1) {
16987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
16988     return 0;
16989   }
16990   arg1 = *argp1;
16991   {
16992     try {
16993       result = Dali::Renderer::DownCast(arg1);
16994     } CALL_CATCH_EXCEPTION(0);
16995   }
16996
16997   jresult = new Dali::Renderer((const Dali::Renderer &)result);
16998   return jresult;
16999 }
17000
17001
17002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_Assign(void * jarg1, void * jarg2) {
17003   void * jresult ;
17004   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
17005   Dali::Renderer *arg2 = 0 ;
17006   Dali::Renderer *result = 0 ;
17007
17008   arg1 = (Dali::Renderer *)jarg1;
17009   arg2 = (Dali::Renderer *)jarg2;
17010   if (!arg2) {
17011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
17012     return 0;
17013   }
17014   {
17015     try {
17016       result = (Dali::Renderer *) &(arg1)->operator =((Dali::Renderer const &)*arg2);
17017     } CALL_CATCH_EXCEPTION(0);
17018   }
17019
17020   jresult = (void *)result;
17021   return jresult;
17022 }
17023
17024
17025 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetGeometry(void * jarg1, void * jarg2) {
17026   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
17027   Dali::Geometry *arg2 = 0 ;
17028
17029   arg1 = (Dali::Renderer *)jarg1;
17030   arg2 = (Dali::Geometry *)jarg2;
17031   if (!arg2) {
17032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
17033     return ;
17034   }
17035   {
17036     try {
17037       (arg1)->SetGeometry(*arg2);
17038     } CALL_CATCH_EXCEPTION();
17039   }
17040
17041 }
17042
17043
17044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetGeometry(void * jarg1) {
17045   void * jresult ;
17046   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
17047   Dali::Geometry result;
17048
17049   arg1 = (Dali::Renderer *)jarg1;
17050   {
17051     try {
17052       result = ((Dali::Renderer const *)arg1)->GetGeometry();
17053     } CALL_CATCH_EXCEPTION(0);
17054   }
17055
17056   jresult = new Dali::Geometry((const Dali::Geometry &)result);
17057   return jresult;
17058 }
17059
17060
17061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetIndexRange(void * jarg1, int jarg2, int jarg3) {
17062   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
17063   int arg2 ;
17064   int arg3 ;
17065
17066   arg1 = (Dali::Renderer *)jarg1;
17067   arg2 = (int)jarg2;
17068   arg3 = (int)jarg3;
17069   {
17070     try {
17071       (arg1)->SetIndexRange(arg2,arg3);
17072     } CALL_CATCH_EXCEPTION();
17073   }
17074
17075 }
17076
17077
17078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetTextures(void * jarg1, void * jarg2) {
17079   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
17080   Dali::TextureSet *arg2 = 0 ;
17081
17082   arg1 = (Dali::Renderer *)jarg1;
17083   arg2 = (Dali::TextureSet *)jarg2;
17084   if (!arg2) {
17085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet & type is null", 0);
17086     return ;
17087   }
17088   {
17089     try {
17090       (arg1)->SetTextures(*arg2);
17091     } CALL_CATCH_EXCEPTION();
17092   }
17093
17094 }
17095
17096
17097 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetTextures(void * jarg1) {
17098   void * jresult ;
17099   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
17100   Dali::TextureSet result;
17101
17102   arg1 = (Dali::Renderer *)jarg1;
17103   {
17104     try {
17105       result = ((Dali::Renderer const *)arg1)->GetTextures();
17106     } CALL_CATCH_EXCEPTION(0);
17107   }
17108
17109   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
17110   return jresult;
17111 }
17112
17113
17114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetShader(void * jarg1, void * jarg2) {
17115   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
17116   Dali::Shader *arg2 = 0 ;
17117
17118   arg1 = (Dali::Renderer *)jarg1;
17119   arg2 = (Dali::Shader *)jarg2;
17120   if (!arg2) {
17121     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
17122     return ;
17123   }
17124   {
17125     try {
17126       (arg1)->SetShader(*arg2);
17127     } CALL_CATCH_EXCEPTION();
17128   }
17129
17130 }
17131
17132
17133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetShader(void * jarg1) {
17134   void * jresult ;
17135   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
17136   Dali::Shader result;
17137
17138   arg1 = (Dali::Renderer *)jarg1;
17139   {
17140     try {
17141       result = ((Dali::Renderer const *)arg1)->GetShader();
17142     } CALL_CATCH_EXCEPTION(0);
17143   }
17144
17145   jresult = new Dali::Shader((const Dali::Shader &)result);
17146   return jresult;
17147 }
17148
17149
17150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer_Attachment() {
17151   void * jresult ;
17152   Dali::FrameBuffer::Attachment *result = 0 ;
17153
17154   {
17155     try {
17156       result = (Dali::FrameBuffer::Attachment *)new Dali::FrameBuffer::Attachment();
17157     } CALL_CATCH_EXCEPTION(0);
17158   }
17159
17160   jresult = (void *)result;
17161   return jresult;
17162 }
17163
17164
17165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer_Attachment(void * jarg1) {
17166   Dali::FrameBuffer::Attachment *arg1 = (Dali::FrameBuffer::Attachment *) 0 ;
17167
17168   arg1 = (Dali::FrameBuffer::Attachment *)jarg1;
17169   {
17170     try {
17171       delete arg1;
17172     } CALL_CATCH_EXCEPTION();
17173   }
17174
17175 }
17176
17177
17178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_New(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
17179   void * jresult ;
17180   unsigned int arg1 ;
17181   unsigned int arg2 ;
17182   unsigned int arg3 ;
17183   Dali::FrameBuffer result;
17184
17185   arg1 = (unsigned int)jarg1;
17186   arg2 = (unsigned int)jarg2;
17187   arg3 = (unsigned int)jarg3;
17188   {
17189     try {
17190       result = Dali::FrameBuffer::New(arg1,arg2,static_cast<Dali::FrameBuffer::Attachment::Mask>(arg3));
17191     } CALL_CATCH_EXCEPTION(0);
17192   }
17193
17194   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
17195   return jresult;
17196 }
17197
17198
17199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_0() {
17200   void * jresult ;
17201   Dali::FrameBuffer *result = 0 ;
17202
17203   {
17204     try {
17205       result = (Dali::FrameBuffer *)new Dali::FrameBuffer();
17206     } CALL_CATCH_EXCEPTION(0);
17207   }
17208
17209   jresult = (void *)result;
17210   return jresult;
17211 }
17212
17213
17214 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer(void * jarg1) {
17215   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
17216
17217   arg1 = (Dali::FrameBuffer *)jarg1;
17218   {
17219     try {
17220       delete arg1;
17221     } CALL_CATCH_EXCEPTION();
17222   }
17223
17224 }
17225
17226
17227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_1(void * jarg1) {
17228   void * jresult ;
17229   Dali::FrameBuffer *arg1 = 0 ;
17230   Dali::FrameBuffer *result = 0 ;
17231
17232   arg1 = (Dali::FrameBuffer *)jarg1;
17233   if (!arg1) {
17234     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
17235     return 0;
17236   }
17237   {
17238     try {
17239       result = (Dali::FrameBuffer *)new Dali::FrameBuffer((Dali::FrameBuffer const &)*arg1);
17240     } CALL_CATCH_EXCEPTION(0);
17241   }
17242
17243   jresult = (void *)result;
17244   return jresult;
17245 }
17246
17247
17248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_DownCast(void * jarg1) {
17249   void * jresult ;
17250   Dali::BaseHandle arg1 ;
17251   Dali::BaseHandle *argp1 ;
17252   Dali::FrameBuffer result;
17253
17254   argp1 = (Dali::BaseHandle *)jarg1;
17255   if (!argp1) {
17256     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
17257     return 0;
17258   }
17259   arg1 = *argp1;
17260   {
17261     try {
17262       result = Dali::FrameBuffer::DownCast(arg1);
17263     } CALL_CATCH_EXCEPTION(0);
17264   }
17265
17266   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
17267   return jresult;
17268 }
17269
17270
17271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_Assign(void * jarg1, void * jarg2) {
17272   void * jresult ;
17273   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
17274   Dali::FrameBuffer *arg2 = 0 ;
17275   Dali::FrameBuffer *result = 0 ;
17276
17277   arg1 = (Dali::FrameBuffer *)jarg1;
17278   arg2 = (Dali::FrameBuffer *)jarg2;
17279   if (!arg2) {
17280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
17281     return 0;
17282   }
17283   {
17284     try {
17285       result = (Dali::FrameBuffer *) &(arg1)->operator =((Dali::FrameBuffer const &)*arg2);
17286     } CALL_CATCH_EXCEPTION(0);
17287   }
17288
17289   jresult = (void *)result;
17290   return jresult;
17291 }
17292
17293
17294 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_0(void * jarg1, void * jarg2) {
17295   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
17296   Dali::Texture *arg2 = 0 ;
17297
17298   arg1 = (Dali::FrameBuffer *)jarg1;
17299   arg2 = (Dali::Texture *)jarg2;
17300   if (!arg2) {
17301     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
17302     return ;
17303   }
17304   {
17305     try {
17306       (arg1)->AttachColorTexture(*arg2);
17307     } CALL_CATCH_EXCEPTION();
17308   }
17309
17310 }
17311
17312
17313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
17314   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
17315   Dali::Texture *arg2 = 0 ;
17316   unsigned int arg3 ;
17317   unsigned int arg4 ;
17318
17319   arg1 = (Dali::FrameBuffer *)jarg1;
17320   arg2 = (Dali::Texture *)jarg2;
17321   if (!arg2) {
17322     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
17323     return ;
17324   }
17325   arg3 = (unsigned int)jarg3;
17326   arg4 = (unsigned int)jarg4;
17327   {
17328     try {
17329       (arg1)->AttachColorTexture(*arg2,arg3,arg4);
17330     } CALL_CATCH_EXCEPTION();
17331   }
17332
17333 }
17334
17335
17336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_GetColorTexture(void * jarg1) {
17337   void * jresult ;
17338   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
17339   Dali::Texture result;
17340
17341   arg1 = (Dali::FrameBuffer *)jarg1;
17342   {
17343     try {
17344       result = (arg1)->GetColorTexture();
17345     } CALL_CATCH_EXCEPTION(0);
17346   }
17347
17348   jresult = new Dali::Texture((const Dali::Texture &)result);
17349   return jresult;
17350 }
17351
17352
17353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_0() {
17354   void * jresult ;
17355   Dali::RenderTaskList *result = 0 ;
17356
17357   {
17358     try {
17359       result = (Dali::RenderTaskList *)new Dali::RenderTaskList();
17360     } CALL_CATCH_EXCEPTION(0);
17361   }
17362
17363   jresult = (void *)result;
17364   return jresult;
17365 }
17366
17367
17368 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_DownCast(void * jarg1) {
17369   void * jresult ;
17370   Dali::BaseHandle arg1 ;
17371   Dali::BaseHandle *argp1 ;
17372   Dali::RenderTaskList result;
17373
17374   argp1 = (Dali::BaseHandle *)jarg1;
17375   if (!argp1) {
17376     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
17377     return 0;
17378   }
17379   arg1 = *argp1;
17380   {
17381     try {
17382       result = Dali::RenderTaskList::DownCast(arg1);
17383     } CALL_CATCH_EXCEPTION(0);
17384   }
17385
17386   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
17387   return jresult;
17388 }
17389
17390
17391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskList(void * jarg1) {
17392   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
17393
17394   arg1 = (Dali::RenderTaskList *)jarg1;
17395   {
17396     try {
17397       delete arg1;
17398     } CALL_CATCH_EXCEPTION();
17399   }
17400
17401 }
17402
17403
17404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_1(void * jarg1) {
17405   void * jresult ;
17406   Dali::RenderTaskList *arg1 = 0 ;
17407   Dali::RenderTaskList *result = 0 ;
17408
17409   arg1 = (Dali::RenderTaskList *)jarg1;
17410   if (!arg1) {
17411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
17412     return 0;
17413   }
17414   {
17415     try {
17416       result = (Dali::RenderTaskList *)new Dali::RenderTaskList((Dali::RenderTaskList const &)*arg1);
17417     } CALL_CATCH_EXCEPTION(0);
17418   }
17419
17420   jresult = (void *)result;
17421   return jresult;
17422 }
17423
17424
17425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_Assign(void * jarg1, void * jarg2) {
17426   void * jresult ;
17427   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
17428   Dali::RenderTaskList *arg2 = 0 ;
17429   Dali::RenderTaskList *result = 0 ;
17430
17431   arg1 = (Dali::RenderTaskList *)jarg1;
17432   arg2 = (Dali::RenderTaskList *)jarg2;
17433   if (!arg2) {
17434     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
17435     return 0;
17436   }
17437   {
17438     try {
17439       result = (Dali::RenderTaskList *) &(arg1)->operator =((Dali::RenderTaskList const &)*arg2);
17440     } CALL_CATCH_EXCEPTION(0);
17441   }
17442
17443   jresult = (void *)result;
17444   return jresult;
17445 }
17446
17447
17448 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_CreateTask(void * jarg1) {
17449   void * jresult ;
17450   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
17451   Dali::RenderTask result;
17452
17453   arg1 = (Dali::RenderTaskList *)jarg1;
17454   {
17455     try {
17456       result = (arg1)->CreateTask();
17457     } CALL_CATCH_EXCEPTION(0);
17458   }
17459
17460   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
17461   return jresult;
17462 }
17463
17464
17465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTaskList_RemoveTask(void * jarg1, void * jarg2) {
17466   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
17467   Dali::RenderTask arg2 ;
17468   Dali::RenderTask *argp2 ;
17469
17470   arg1 = (Dali::RenderTaskList *)jarg1;
17471   argp2 = (Dali::RenderTask *)jarg2;
17472   if (!argp2) {
17473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RenderTask", 0);
17474     return ;
17475   }
17476   arg2 = *argp2;
17477   {
17478     try {
17479       (arg1)->RemoveTask(arg2);
17480     } CALL_CATCH_EXCEPTION();
17481   }
17482
17483 }
17484
17485
17486 //// ===============================================end part 1 =================
17487
17488 //// ========================= part 2 ===============================
17489
17490 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTaskCount(void * jarg1) {
17491   unsigned int jresult ;
17492   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
17493   unsigned int result;
17494
17495   arg1 = (Dali::RenderTaskList *)jarg1;
17496   {
17497     try {
17498       result = (unsigned int)((Dali::RenderTaskList const *)arg1)->GetTaskCount();
17499     } CALL_CATCH_EXCEPTION(0);
17500   }
17501
17502   jresult = result;
17503   return jresult;
17504 }
17505
17506
17507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTask(void * jarg1, unsigned int jarg2) {
17508   void * jresult ;
17509   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
17510   unsigned int arg2 ;
17511   Dali::RenderTask result;
17512
17513   arg1 = (Dali::RenderTaskList *)jarg1;
17514   arg2 = (unsigned int)jarg2;
17515   {
17516     try {
17517       result = ((Dali::RenderTaskList const *)arg1)->GetTask(arg2);
17518     } CALL_CATCH_EXCEPTION(0);
17519   }
17520
17521   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
17522   return jresult;
17523 }
17524
17525
17526 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_POSITION_get() {
17527   int jresult ;
17528   int result;
17529
17530   result = (int)Dali::RenderTask::Property::VIEWPORT_POSITION;
17531   jresult = (int)result;
17532   return jresult;
17533 }
17534
17535
17536 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_SIZE_get() {
17537   int jresult ;
17538   int result;
17539
17540   result = (int)Dali::RenderTask::Property::VIEWPORT_SIZE;
17541   jresult = (int)result;
17542   return jresult;
17543 }
17544
17545
17546 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_CLEAR_COLOR_get() {
17547   int jresult ;
17548   int result;
17549
17550   result = (int)Dali::RenderTask::Property::CLEAR_COLOR;
17551   jresult = (int)result;
17552   return jresult;
17553 }
17554
17555
17556 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_REQUIRES_SYNC_get() {
17557   int jresult ;
17558   int result;
17559
17560   result = (int)Dali::RenderTask::Property::REQUIRES_SYNC;
17561   jresult = (int)result;
17562   return jresult;
17563 }
17564
17565
17566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask_Property() {
17567   void * jresult ;
17568   Dali::RenderTask::Property *result = 0 ;
17569
17570   {
17571     try {
17572       result = (Dali::RenderTask::Property *)new Dali::RenderTask::Property();
17573     } CALL_CATCH_EXCEPTION(0);
17574   }
17575
17576   jresult = (void *)result;
17577   return jresult;
17578 }
17579
17580
17581 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask_Property(void * jarg1) {
17582   Dali::RenderTask::Property *arg1 = (Dali::RenderTask::Property *) 0 ;
17583
17584   arg1 = (Dali::RenderTask::Property *)jarg1;
17585   {
17586     try {
17587       delete arg1;
17588     } CALL_CATCH_EXCEPTION();
17589   }
17590
17591 }
17592
17593
17594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION_get() {
17595   void * jresult ;
17596   bool (*result)(Dali::Vector2 &) = 0 ;
17597
17598   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION;
17599   jresult = (void *)result;
17600   return jresult;
17601 }
17602
17603
17604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FULLSCREEN_FRAMEBUFFER_FUNCTION_get() {
17605   void * jresult ;
17606   bool (*result)(Dali::Vector2 &) = 0 ;
17607
17608   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION;
17609   jresult = (void *)result;
17610   return jresult;
17611 }
17612
17613
17614 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_EXCLUSIVE_get() {
17615   unsigned int jresult ;
17616   bool result;
17617
17618   result = (bool)(bool)Dali::RenderTask::DEFAULT_EXCLUSIVE;
17619   jresult = result;
17620   return jresult;
17621 }
17622
17623
17624 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_INPUT_ENABLED_get() {
17625   unsigned int jresult ;
17626   bool result;
17627
17628   result = (bool)(bool)Dali::RenderTask::DEFAULT_INPUT_ENABLED;
17629   jresult = result;
17630   return jresult;
17631 }
17632
17633
17634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_COLOR_get() {
17635   void * jresult ;
17636   Dali::Vector4 *result = 0 ;
17637
17638   result = (Dali::Vector4 *)&Dali::RenderTask::DEFAULT_CLEAR_COLOR;
17639   jresult = (void *)result;
17640   return jresult;
17641 }
17642
17643
17644 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_ENABLED_get() {
17645   unsigned int jresult ;
17646   bool result;
17647
17648   result = (bool)(bool)Dali::RenderTask::DEFAULT_CLEAR_ENABLED;
17649   jresult = result;
17650   return jresult;
17651 }
17652
17653
17654 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CULL_MODE_get() {
17655   unsigned int jresult ;
17656   bool result;
17657
17658   result = (bool)(bool)Dali::RenderTask::DEFAULT_CULL_MODE;
17659   jresult = result;
17660   return jresult;
17661 }
17662
17663
17664 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_REFRESH_RATE_get() {
17665   unsigned int jresult ;
17666   unsigned int result;
17667
17668   result = (unsigned int)(unsigned int)Dali::RenderTask::DEFAULT_REFRESH_RATE;
17669   jresult = result;
17670   return jresult;
17671 }
17672
17673
17674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_0() {
17675   void * jresult ;
17676   Dali::RenderTask *result = 0 ;
17677
17678   {
17679     try {
17680       result = (Dali::RenderTask *)new Dali::RenderTask();
17681     } CALL_CATCH_EXCEPTION(0);
17682   }
17683
17684   jresult = (void *)result;
17685   return jresult;
17686 }
17687
17688
17689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DownCast(void * jarg1) {
17690   void * jresult ;
17691   Dali::BaseHandle arg1 ;
17692   Dali::BaseHandle *argp1 ;
17693   Dali::RenderTask result;
17694
17695   argp1 = (Dali::BaseHandle *)jarg1;
17696   if (!argp1) {
17697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
17698     return 0;
17699   }
17700   arg1 = *argp1;
17701   {
17702     try {
17703       result = Dali::RenderTask::DownCast(arg1);
17704     } CALL_CATCH_EXCEPTION(0);
17705   }
17706
17707   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
17708   return jresult;
17709 }
17710
17711
17712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask(void * jarg1) {
17713   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
17714
17715   arg1 = (Dali::RenderTask *)jarg1;
17716   {
17717     try {
17718       delete arg1;
17719     } CALL_CATCH_EXCEPTION();
17720   }
17721
17722 }
17723
17724
17725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_1(void * jarg1) {
17726   void * jresult ;
17727   Dali::RenderTask *arg1 = 0 ;
17728   Dali::RenderTask *result = 0 ;
17729
17730   arg1 = (Dali::RenderTask *)jarg1;
17731   if (!arg1) {
17732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
17733     return 0;
17734   }
17735   {
17736     try {
17737       result = (Dali::RenderTask *)new Dali::RenderTask((Dali::RenderTask const &)*arg1);
17738     } CALL_CATCH_EXCEPTION(0);
17739   }
17740
17741   jresult = (void *)result;
17742   return jresult;
17743 }
17744
17745
17746 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_Assign(void * jarg1, void * jarg2) {
17747   void * jresult ;
17748   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
17749   Dali::RenderTask *arg2 = 0 ;
17750   Dali::RenderTask *result = 0 ;
17751
17752   arg1 = (Dali::RenderTask *)jarg1;
17753   arg2 = (Dali::RenderTask *)jarg2;
17754   if (!arg2) {
17755     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
17756     return 0;
17757   }
17758   {
17759     try {
17760       result = (Dali::RenderTask *) &(arg1)->operator =((Dali::RenderTask const &)*arg2);
17761     } CALL_CATCH_EXCEPTION(0);
17762   }
17763
17764   jresult = (void *)result;
17765   return jresult;
17766 }
17767
17768
17769 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetSourceActor(void * jarg1, void * jarg2) {
17770   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
17771   Dali::Actor arg2 ;
17772   Dali::Actor *argp2 ;
17773
17774   arg1 = (Dali::RenderTask *)jarg1;
17775   argp2 = (Dali::Actor *)jarg2;
17776   if (!argp2) {
17777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
17778     return ;
17779   }
17780   arg2 = *argp2;
17781   {
17782     try {
17783       (arg1)->SetSourceActor(arg2);
17784     } CALL_CATCH_EXCEPTION();
17785   }
17786
17787 }
17788
17789
17790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetSourceActor(void * jarg1) {
17791   void * jresult ;
17792   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
17793   Dali::Actor result;
17794
17795   arg1 = (Dali::RenderTask *)jarg1;
17796   {
17797     try {
17798       result = ((Dali::RenderTask const *)arg1)->GetSourceActor();
17799     } CALL_CATCH_EXCEPTION(0);
17800   }
17801
17802   jresult = new Dali::Actor((const Dali::Actor &)result);
17803   return jresult;
17804 }
17805
17806
17807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetExclusive(void * jarg1, unsigned int jarg2) {
17808   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
17809   bool arg2 ;
17810
17811   arg1 = (Dali::RenderTask *)jarg1;
17812   arg2 = jarg2 ? true : false;
17813   {
17814     try {
17815       (arg1)->SetExclusive(arg2);
17816     } CALL_CATCH_EXCEPTION();
17817   }
17818
17819 }
17820
17821
17822 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_IsExclusive(void * jarg1) {
17823   unsigned int jresult ;
17824   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
17825   bool result;
17826
17827   arg1 = (Dali::RenderTask *)jarg1;
17828   {
17829     try {
17830       result = (bool)((Dali::RenderTask const *)arg1)->IsExclusive();
17831     } CALL_CATCH_EXCEPTION(0);
17832   }
17833
17834   jresult = result;
17835   return jresult;
17836 }
17837
17838
17839 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetInputEnabled(void * jarg1, unsigned int jarg2) {
17840   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
17841   bool arg2 ;
17842
17843   arg1 = (Dali::RenderTask *)jarg1;
17844   arg2 = jarg2 ? true : false;
17845   {
17846     try {
17847       (arg1)->SetInputEnabled(arg2);
17848     } CALL_CATCH_EXCEPTION();
17849   }
17850
17851 }
17852
17853
17854 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetInputEnabled(void * jarg1) {
17855   unsigned int jresult ;
17856   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
17857   bool result;
17858
17859   arg1 = (Dali::RenderTask *)jarg1;
17860   {
17861     try {
17862       result = (bool)((Dali::RenderTask const *)arg1)->GetInputEnabled();
17863     } CALL_CATCH_EXCEPTION(0);
17864   }
17865
17866   jresult = result;
17867   return jresult;
17868 }
17869
17870
17871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCameraActor(void * jarg1, void * jarg2) {
17872   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
17873   Dali::CameraActor arg2 ;
17874   Dali::CameraActor *argp2 ;
17875
17876   arg1 = (Dali::RenderTask *)jarg1;
17877   argp2 = (Dali::CameraActor *)jarg2;
17878   if (!argp2) {
17879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::CameraActor", 0);
17880     return ;
17881   }
17882   arg2 = *argp2;
17883   {
17884     try {
17885       (arg1)->SetCameraActor(arg2);
17886     } CALL_CATCH_EXCEPTION();
17887   }
17888
17889 }
17890
17891
17892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCameraActor(void * jarg1) {
17893   void * jresult ;
17894   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
17895   Dali::CameraActor result;
17896
17897   arg1 = (Dali::RenderTask *)jarg1;
17898   {
17899     try {
17900       result = ((Dali::RenderTask const *)arg1)->GetCameraActor();
17901     } CALL_CATCH_EXCEPTION(0);
17902   }
17903
17904   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
17905   return jresult;
17906 }
17907
17908
17909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetFrameBuffer(void * jarg1, void * jarg2) {
17910   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
17911   Dali::FrameBuffer arg2 ;
17912   Dali::FrameBuffer *argp2 ;
17913
17914   arg1 = (Dali::RenderTask *)jarg1;
17915   argp2 = (Dali::FrameBuffer *)jarg2;
17916   if (!argp2) {
17917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
17918     return ;
17919   }
17920   arg2 = *argp2;
17921   {
17922     try {
17923       (arg1)->SetFrameBuffer(arg2);
17924     } CALL_CATCH_EXCEPTION();
17925   }
17926
17927 }
17928
17929
17930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetFrameBuffer(void * jarg1) {
17931   void * jresult ;
17932   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
17933   Dali::FrameBuffer result;
17934
17935   arg1 = (Dali::RenderTask *)jarg1;
17936   {
17937     try {
17938       result = ((Dali::RenderTask const *)arg1)->GetFrameBuffer();
17939     } CALL_CATCH_EXCEPTION(0);
17940   }
17941
17942   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
17943   return jresult;
17944 }
17945
17946
17947 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferFunction(void * jarg1, void * jarg2) {
17948   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
17949   Dali::RenderTask::ScreenToFrameBufferFunction arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction) 0 ;
17950
17951   arg1 = (Dali::RenderTask *)jarg1;
17952   arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction)jarg2;
17953   {
17954     try {
17955       (arg1)->SetScreenToFrameBufferFunction(arg2);
17956     } CALL_CATCH_EXCEPTION();
17957   }
17958
17959 }
17960
17961
17962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferFunction(void * jarg1) {
17963   void * jresult ;
17964   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
17965   Dali::RenderTask::ScreenToFrameBufferFunction result;
17966
17967   arg1 = (Dali::RenderTask *)jarg1;
17968   {
17969     try {
17970       result = (Dali::RenderTask::ScreenToFrameBufferFunction)((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferFunction();
17971     } CALL_CATCH_EXCEPTION(0);
17972   }
17973
17974   jresult = (void *)result;
17975   return jresult;
17976 }
17977
17978
17979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferMappingActor(void * jarg1, void * jarg2) {
17980   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
17981   Dali::Actor arg2 ;
17982   Dali::Actor *argp2 ;
17983
17984   arg1 = (Dali::RenderTask *)jarg1;
17985   argp2 = (Dali::Actor *)jarg2;
17986   if (!argp2) {
17987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
17988     return ;
17989   }
17990   arg2 = *argp2;
17991   {
17992     try {
17993       (arg1)->SetScreenToFrameBufferMappingActor(arg2);
17994     } CALL_CATCH_EXCEPTION();
17995   }
17996
17997 }
17998
17999
18000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferMappingActor(void * jarg1) {
18001   void * jresult ;
18002   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18003   Dali::Actor result;
18004
18005   arg1 = (Dali::RenderTask *)jarg1;
18006   {
18007     try {
18008       result = ((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferMappingActor();
18009     } CALL_CATCH_EXCEPTION(0);
18010   }
18011
18012   jresult = new Dali::Actor((const Dali::Actor &)result);
18013   return jresult;
18014 }
18015
18016
18017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportPosition(void * jarg1, void * jarg2) {
18018   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18019   Dali::Vector2 arg2 ;
18020   Dali::Vector2 *argp2 ;
18021
18022   arg1 = (Dali::RenderTask *)jarg1;
18023   argp2 = (Dali::Vector2 *)jarg2;
18024   if (!argp2) {
18025     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
18026     return ;
18027   }
18028   arg2 = *argp2;
18029   {
18030     try {
18031       (arg1)->SetViewportPosition(arg2);
18032     } CALL_CATCH_EXCEPTION();
18033   }
18034
18035 }
18036
18037
18038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportPosition(void * jarg1) {
18039   void * jresult ;
18040   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18041   Dali::Vector2 result;
18042
18043   arg1 = (Dali::RenderTask *)jarg1;
18044   {
18045     try {
18046       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportPosition();
18047     } CALL_CATCH_EXCEPTION(0);
18048   }
18049
18050   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
18051   return jresult;
18052 }
18053
18054
18055 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportSize(void * jarg1, void * jarg2) {
18056   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18057   Dali::Vector2 arg2 ;
18058   Dali::Vector2 *argp2 ;
18059
18060   arg1 = (Dali::RenderTask *)jarg1;
18061   argp2 = (Dali::Vector2 *)jarg2;
18062   if (!argp2) {
18063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
18064     return ;
18065   }
18066   arg2 = *argp2;
18067   {
18068     try {
18069       (arg1)->SetViewportSize(arg2);
18070     } CALL_CATCH_EXCEPTION();
18071   }
18072
18073 }
18074
18075
18076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportSize(void * jarg1) {
18077   void * jresult ;
18078   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18079   Dali::Vector2 result;
18080
18081   arg1 = (Dali::RenderTask *)jarg1;
18082   {
18083     try {
18084       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportSize();
18085     } CALL_CATCH_EXCEPTION(0);
18086   }
18087
18088   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
18089   return jresult;
18090 }
18091
18092
18093 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewport(void * jarg1, void * jarg2) {
18094   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18095   Dali::Viewport arg2 ;
18096   Dali::Viewport *argp2 ;
18097
18098   arg1 = (Dali::RenderTask *)jarg1;
18099   argp2 = (Dali::Viewport *)jarg2;
18100   if (!argp2) {
18101     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Viewport", 0);
18102     return ;
18103   }
18104   arg2 = *argp2;
18105   {
18106     try {
18107       (arg1)->SetViewport(arg2);
18108     } CALL_CATCH_EXCEPTION();
18109   }
18110
18111 }
18112
18113
18114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetViewport(void * jarg1) {
18115   void * jresult ;
18116   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18117   Dali::Viewport result;
18118
18119   arg1 = (Dali::RenderTask *)jarg1;
18120   {
18121     try {
18122       result = ((Dali::RenderTask const *)arg1)->GetViewport();
18123     } CALL_CATCH_EXCEPTION(0);
18124   }
18125
18126   jresult = new Dali::Viewport((const Dali::Viewport &)result);
18127   return jresult;
18128 }
18129
18130
18131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearColor(void * jarg1, void * jarg2) {
18132   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18133   Dali::Vector4 *arg2 = 0 ;
18134
18135   arg1 = (Dali::RenderTask *)jarg1;
18136   arg2 = (Dali::Vector4 *)jarg2;
18137   if (!arg2) {
18138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
18139     return ;
18140   }
18141   {
18142     try {
18143       (arg1)->SetClearColor((Dali::Vector4 const &)*arg2);
18144     } CALL_CATCH_EXCEPTION();
18145   }
18146
18147 }
18148
18149
18150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetClearColor(void * jarg1) {
18151   void * jresult ;
18152   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18153   Dali::Vector4 result;
18154
18155   arg1 = (Dali::RenderTask *)jarg1;
18156   {
18157     try {
18158       result = ((Dali::RenderTask const *)arg1)->GetClearColor();
18159     } CALL_CATCH_EXCEPTION(0);
18160   }
18161
18162   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
18163   return jresult;
18164 }
18165
18166
18167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearEnabled(void * jarg1, unsigned int jarg2) {
18168   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18169   bool arg2 ;
18170
18171   arg1 = (Dali::RenderTask *)jarg1;
18172   arg2 = jarg2 ? true : false;
18173   {
18174     try {
18175       (arg1)->SetClearEnabled(arg2);
18176     } CALL_CATCH_EXCEPTION();
18177   }
18178
18179 }
18180
18181
18182 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetClearEnabled(void * jarg1) {
18183   unsigned int jresult ;
18184   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18185   bool result;
18186
18187   arg1 = (Dali::RenderTask *)jarg1;
18188   {
18189     try {
18190       result = (bool)((Dali::RenderTask const *)arg1)->GetClearEnabled();
18191     } CALL_CATCH_EXCEPTION(0);
18192   }
18193
18194   jresult = result;
18195   return jresult;
18196 }
18197
18198
18199 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCullMode(void * jarg1, unsigned int jarg2) {
18200   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18201   bool arg2 ;
18202
18203   arg1 = (Dali::RenderTask *)jarg1;
18204   arg2 = jarg2 ? true : false;
18205   {
18206     try {
18207       (arg1)->SetCullMode(arg2);
18208     } CALL_CATCH_EXCEPTION();
18209   }
18210
18211 }
18212
18213
18214 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetCullMode(void * jarg1) {
18215   unsigned int jresult ;
18216   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18217   bool result;
18218
18219   arg1 = (Dali::RenderTask *)jarg1;
18220   {
18221     try {
18222       result = (bool)((Dali::RenderTask const *)arg1)->GetCullMode();
18223     } CALL_CATCH_EXCEPTION(0);
18224   }
18225
18226   jresult = result;
18227   return jresult;
18228 }
18229
18230
18231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetRefreshRate(void * jarg1, unsigned int jarg2) {
18232   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18233   unsigned int arg2 ;
18234
18235   arg1 = (Dali::RenderTask *)jarg1;
18236   arg2 = (unsigned int)jarg2;
18237   {
18238     try {
18239       (arg1)->SetRefreshRate(arg2);
18240     } CALL_CATCH_EXCEPTION();
18241   }
18242
18243 }
18244
18245
18246 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetRefreshRate(void * jarg1) {
18247   unsigned int jresult ;
18248   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18249   unsigned int result;
18250
18251   arg1 = (Dali::RenderTask *)jarg1;
18252   {
18253     try {
18254       result = (unsigned int)((Dali::RenderTask const *)arg1)->GetRefreshRate();
18255     } CALL_CATCH_EXCEPTION(0);
18256   }
18257
18258   jresult = result;
18259   return jresult;
18260 }
18261
18262
18263 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_WorldToViewport(void * jarg1, void * jarg2, float * jarg3, float * jarg4) {
18264   unsigned int jresult ;
18265   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18266   Dali::Vector3 *arg2 = 0 ;
18267   float *arg3 = 0 ;
18268   float *arg4 = 0 ;
18269   bool result;
18270
18271   arg1 = (Dali::RenderTask *)jarg1;
18272   arg2 = (Dali::Vector3 *)jarg2;
18273   if (!arg2) {
18274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
18275     return 0;
18276   }
18277   arg3 = (float *)jarg3;
18278   arg4 = (float *)jarg4;
18279   {
18280     try {
18281       result = (bool)((Dali::RenderTask const *)arg1)->WorldToViewport((Dali::Vector3 const &)*arg2,*arg3,*arg4);
18282     } CALL_CATCH_EXCEPTION(0);
18283   }
18284
18285   jresult = result;
18286   return jresult;
18287 }
18288
18289
18290 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_ViewportToLocal(void * jarg1, void * jarg2, float jarg3, float jarg4, float * jarg5, float * jarg6) {
18291   unsigned int jresult ;
18292   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18293   Dali::Actor arg2 ;
18294   float arg3 ;
18295   float arg4 ;
18296   float *arg5 = 0 ;
18297   float *arg6 = 0 ;
18298   Dali::Actor *argp2 ;
18299   bool result;
18300
18301   arg1 = (Dali::RenderTask *)jarg1;
18302   argp2 = (Dali::Actor *)jarg2;
18303   if (!argp2) {
18304     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
18305     return 0;
18306   }
18307   arg2 = *argp2;
18308   arg3 = (float)jarg3;
18309   arg4 = (float)jarg4;
18310   arg5 = (float *)jarg5;
18311   arg6 = (float *)jarg6;
18312   {
18313     try {
18314       result = (bool)((Dali::RenderTask const *)arg1)->ViewportToLocal(arg2,arg3,arg4,*arg5,*arg6);
18315     } CALL_CATCH_EXCEPTION(0);
18316   }
18317
18318   jresult = result;
18319   return jresult;
18320 }
18321
18322
18323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FinishedSignal(void * jarg1) {
18324   void * jresult ;
18325   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18326   Dali::RenderTask::RenderTaskSignalType *result = 0 ;
18327
18328   arg1 = (Dali::RenderTask *)jarg1;
18329   {
18330     try {
18331       result = (Dali::RenderTask::RenderTaskSignalType *) &(arg1)->FinishedSignal();
18332     } CALL_CATCH_EXCEPTION(0);
18333   }
18334
18335   jresult = (void *)result;
18336   return jresult;
18337 }
18338
18339
18340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_0(int jarg1, int jarg2, float jarg3, float jarg4) {
18341   void * jresult ;
18342   int arg1 ;
18343   Dali::PointState::Type arg2 ;
18344   float arg3 ;
18345   float arg4 ;
18346   Dali::TouchPoint *result = 0 ;
18347
18348   arg1 = (int)jarg1;
18349   arg2 = (Dali::PointState::Type)jarg2;
18350   arg3 = (float)jarg3;
18351   arg4 = (float)jarg4;
18352   {
18353     try {
18354       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4);
18355     } CALL_CATCH_EXCEPTION(0);
18356   }
18357
18358   jresult = (void *)result;
18359   return jresult;
18360 }
18361
18362
18363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_1(int jarg1, int jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
18364   void * jresult ;
18365   int arg1 ;
18366   Dali::PointState::Type arg2 ;
18367   float arg3 ;
18368   float arg4 ;
18369   float arg5 ;
18370   float arg6 ;
18371   Dali::TouchPoint *result = 0 ;
18372
18373   arg1 = (int)jarg1;
18374   arg2 = (Dali::PointState::Type)jarg2;
18375   arg3 = (float)jarg3;
18376   arg4 = (float)jarg4;
18377   arg5 = (float)jarg5;
18378   arg6 = (float)jarg6;
18379   {
18380     try {
18381       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4,arg5,arg6);
18382     } CALL_CATCH_EXCEPTION(0);
18383   }
18384
18385   jresult = (void *)result;
18386   return jresult;
18387 }
18388
18389
18390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPoint(void * jarg1) {
18391   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
18392
18393   arg1 = (Dali::TouchPoint *)jarg1;
18394   {
18395     try {
18396       delete arg1;
18397     } CALL_CATCH_EXCEPTION();
18398   }
18399
18400 }
18401
18402
18403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_set(void * jarg1, int jarg2) {
18404   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
18405   int arg2 ;
18406
18407   arg1 = (Dali::TouchPoint *)jarg1;
18408   arg2 = (int)jarg2;
18409   if (arg1) (arg1)->deviceId = arg2;
18410 }
18411
18412
18413 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_get(void * jarg1) {
18414   int jresult ;
18415   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
18416   int result;
18417
18418   arg1 = (Dali::TouchPoint *)jarg1;
18419   result = (int) ((arg1)->deviceId);
18420   jresult = result;
18421   return jresult;
18422 }
18423
18424
18425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_state_set(void * jarg1, int jarg2) {
18426   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
18427   Dali::PointState::Type arg2 ;
18428
18429   arg1 = (Dali::TouchPoint *)jarg1;
18430   arg2 = (Dali::PointState::Type)jarg2;
18431   if (arg1) (arg1)->state = arg2;
18432 }
18433
18434
18435 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_state_get(void * jarg1) {
18436   int jresult ;
18437   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
18438   Dali::PointState::Type result;
18439
18440   arg1 = (Dali::TouchPoint *)jarg1;
18441   result = (Dali::PointState::Type) ((arg1)->state);
18442   jresult = (int)result;
18443   return jresult;
18444 }
18445
18446
18447 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_set(void * jarg1, void * jarg2) {
18448   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
18449   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
18450
18451   arg1 = (Dali::TouchPoint *)jarg1;
18452   arg2 = (Dali::Actor *)jarg2;
18453   if (arg1) (arg1)->hitActor = *arg2;
18454 }
18455
18456
18457 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_get(void * jarg1) {
18458   void * jresult ;
18459   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
18460   Dali::Actor *result = 0 ;
18461
18462   arg1 = (Dali::TouchPoint *)jarg1;
18463   result = (Dali::Actor *)& ((arg1)->hitActor);
18464   jresult = (void *)result;
18465   return jresult;
18466 }
18467
18468
18469 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_local_set(void * jarg1, void * jarg2) {
18470   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
18471   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
18472
18473   arg1 = (Dali::TouchPoint *)jarg1;
18474   arg2 = (Dali::Vector2 *)jarg2;
18475   if (arg1) (arg1)->local = *arg2;
18476 }
18477
18478
18479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_local_get(void * jarg1) {
18480   void * jresult ;
18481   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
18482   Dali::Vector2 *result = 0 ;
18483
18484   arg1 = (Dali::TouchPoint *)jarg1;
18485   result = (Dali::Vector2 *)& ((arg1)->local);
18486   jresult = (void *)result;
18487   return jresult;
18488 }
18489
18490
18491 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_screen_set(void * jarg1, void * jarg2) {
18492   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
18493   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
18494
18495   arg1 = (Dali::TouchPoint *)jarg1;
18496   arg2 = (Dali::Vector2 *)jarg2;
18497   if (arg1) (arg1)->screen = *arg2;
18498 }
18499
18500
18501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_screen_get(void * jarg1) {
18502   void * jresult ;
18503   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
18504   Dali::Vector2 *result = 0 ;
18505
18506   arg1 = (Dali::TouchPoint *)jarg1;
18507   result = (Dali::Vector2 *)& ((arg1)->screen);
18508   jresult = (void *)result;
18509   return jresult;
18510 }
18511
18512
18513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_0() {
18514   void * jresult ;
18515   Dali::TouchEvent *result = 0 ;
18516
18517   {
18518     try {
18519       result = (Dali::TouchEvent *)new Dali::TouchEvent();
18520     } CALL_CATCH_EXCEPTION(0);
18521   }
18522
18523   jresult = (void *)result;
18524   return jresult;
18525 }
18526
18527
18528 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_1(void * jarg1) {
18529   void * jresult ;
18530   Dali::TouchEvent *arg1 = 0 ;
18531   Dali::TouchEvent *result = 0 ;
18532
18533   arg1 = (Dali::TouchEvent *)jarg1;
18534   if (!arg1) {
18535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
18536     return 0;
18537   }
18538   {
18539     try {
18540       result = (Dali::TouchEvent *)new Dali::TouchEvent((Dali::TouchEvent const &)*arg1);
18541     } CALL_CATCH_EXCEPTION(0);
18542   }
18543
18544   jresult = (void *)result;
18545   return jresult;
18546 }
18547
18548
18549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Touch(void * jarg1) {
18550   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
18551
18552   arg1 = (Dali::TouchEvent *)jarg1;
18553   {
18554     try {
18555       delete arg1;
18556     } CALL_CATCH_EXCEPTION();
18557   }
18558
18559 }
18560
18561
18562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_Assign(void * jarg1, void * jarg2) {
18563   void * jresult ;
18564   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
18565   Dali::TouchEvent *arg2 = 0 ;
18566   Dali::TouchEvent *result = 0 ;
18567
18568   arg1 = (Dali::TouchEvent *)jarg1;
18569   arg2 = (Dali::TouchEvent *)jarg2;
18570   if (!arg2) {
18571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
18572     return 0;
18573   }
18574   {
18575     try {
18576       result = (Dali::TouchEvent *) &(arg1)->operator =((Dali::TouchEvent const &)*arg2);
18577     } CALL_CATCH_EXCEPTION(0);
18578   }
18579
18580   jresult = (void *)result;
18581   return jresult;
18582 }
18583
18584
18585 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetTime(void * jarg1) {
18586   unsigned long jresult ;
18587   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
18588   unsigned long result;
18589
18590   arg1 = (Dali::TouchEvent *)jarg1;
18591   {
18592     try {
18593       result = (unsigned long)((Dali::TouchEvent const *)arg1)->GetTime();
18594     } CALL_CATCH_EXCEPTION(0);
18595   }
18596
18597   jresult = (unsigned long)result;
18598   return jresult;
18599 }
18600
18601
18602 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetPointCount(void * jarg1) {
18603   unsigned long jresult ;
18604   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
18605   std::size_t result;
18606
18607   arg1 = (Dali::TouchEvent *)jarg1;
18608   {
18609     try {
18610       result = ((Dali::TouchEvent const *)arg1)->GetPointCount();
18611     } CALL_CATCH_EXCEPTION(0);
18612   }
18613
18614   jresult = (unsigned long)result;
18615   return jresult;
18616 }
18617
18618
18619 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceId(void * jarg1, unsigned long jarg2) {
18620   int jresult ;
18621   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
18622   std::size_t arg2 ;
18623   int32_t result;
18624
18625   arg1 = (Dali::TouchEvent *)jarg1;
18626   arg2 = (std::size_t)jarg2;
18627   {
18628     try {
18629       result = ((Dali::TouchEvent const *)arg1)->GetDeviceId(arg2);
18630     } CALL_CATCH_EXCEPTION(0);
18631   }
18632
18633   jresult = result;
18634   return jresult;
18635 }
18636
18637
18638 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetState(void * jarg1, unsigned long jarg2) {
18639   int jresult ;
18640   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
18641   std::size_t arg2 ;
18642   Dali::PointState::Type result;
18643
18644   arg1 = (Dali::TouchEvent *)jarg1;
18645   arg2 = (std::size_t)jarg2;
18646   {
18647     try {
18648       result = (Dali::PointState::Type)((Dali::TouchEvent const *)arg1)->GetState(arg2);
18649     } CALL_CATCH_EXCEPTION(0);
18650   }
18651
18652   jresult = (int)result;
18653   return jresult;
18654 }
18655
18656
18657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetHitActor(void * jarg1, unsigned long jarg2) {
18658   void * jresult ;
18659   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
18660   std::size_t arg2 ;
18661   Dali::Actor result;
18662
18663   arg1 = (Dali::TouchEvent *)jarg1;
18664   arg2 = (std::size_t)jarg2;
18665   {
18666     try {
18667       result = ((Dali::TouchEvent const *)arg1)->GetHitActor(arg2);
18668     } CALL_CATCH_EXCEPTION(0);
18669   }
18670
18671   jresult = new Dali::Actor((const Dali::Actor &)result);
18672   return jresult;
18673 }
18674
18675
18676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetLocalPosition(void * jarg1, unsigned long jarg2) {
18677   void * jresult ;
18678   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
18679   std::size_t arg2 ;
18680   Dali::Vector2 *result = 0 ;
18681
18682   arg1 = (Dali::TouchEvent *)jarg1;
18683   arg2 = (std::size_t)jarg2;
18684   {
18685     try {
18686       result = (Dali::Vector2 *) &((Dali::TouchEvent const *)arg1)->GetLocalPosition(arg2);
18687     } CALL_CATCH_EXCEPTION(0);
18688   }
18689
18690   jresult = (void *)result;
18691   return jresult;
18692 }
18693
18694
18695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetScreenPosition(void * jarg1, unsigned long jarg2) {
18696   void * jresult ;
18697   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
18698   std::size_t arg2 ;
18699   Dali::Vector2 *result = 0 ;
18700
18701   arg1 = (Dali::TouchEvent *)jarg1;
18702   arg2 = (std::size_t)jarg2;
18703   {
18704     try {
18705       result = (Dali::Vector2 *) &((Dali::TouchEvent const *)arg1)->GetScreenPosition(arg2);
18706     } CALL_CATCH_EXCEPTION(0);
18707   }
18708
18709   jresult = (void *)result;
18710   return jresult;
18711 }
18712
18713
18714 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetRadius(void * jarg1, unsigned long jarg2) {
18715   float jresult ;
18716   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
18717   std::size_t arg2 ;
18718   float result;
18719
18720   arg1 = (Dali::TouchEvent *)jarg1;
18721   arg2 = (std::size_t)jarg2;
18722   {
18723     try {
18724       result = (float)((Dali::TouchEvent const *)arg1)->GetRadius(arg2);
18725     } CALL_CATCH_EXCEPTION(0);
18726   }
18727
18728   jresult = result;
18729   return jresult;
18730 }
18731
18732
18733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetEllipseRadius(void * jarg1, unsigned long jarg2) {
18734   void * jresult ;
18735   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
18736   std::size_t arg2 ;
18737   Dali::Vector2 *result = 0 ;
18738
18739   arg1 = (Dali::TouchEvent *)jarg1;
18740   arg2 = (std::size_t)jarg2;
18741   {
18742     try {
18743       result = (Dali::Vector2 *) &((Dali::TouchEvent const *)arg1)->GetEllipseRadius(arg2);
18744     } CALL_CATCH_EXCEPTION(0);
18745   }
18746
18747   jresult = (void *)result;
18748   return jresult;
18749 }
18750
18751
18752 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetPressure(void * jarg1, unsigned long jarg2) {
18753   float jresult ;
18754   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
18755   std::size_t arg2 ;
18756   float result;
18757
18758   arg1 = (Dali::TouchEvent *)jarg1;
18759   arg2 = (std::size_t)jarg2;
18760   {
18761     try {
18762       result = (float)((Dali::TouchEvent const *)arg1)->GetPressure(arg2);
18763     } CALL_CATCH_EXCEPTION(0);
18764   }
18765
18766   jresult = result;
18767   return jresult;
18768 }
18769
18770
18771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetAngle(void * jarg1, unsigned long jarg2) {
18772   void * jresult ;
18773   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
18774   std::size_t arg2 ;
18775   Dali::Degree result;
18776
18777   arg1 = (Dali::TouchEvent *)jarg1;
18778   arg2 = (std::size_t)jarg2;
18779   {
18780     try {
18781       result = ((Dali::TouchEvent const *)arg1)->GetAngle(arg2);
18782     } CALL_CATCH_EXCEPTION(0);
18783   }
18784
18785   jresult = new Dali::Degree((const Dali::Degree &)result);
18786   return jresult;
18787 }
18788
18789
18790 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetMouseButton(void * jarg1, unsigned long jarg2) {
18791   int jresult ;
18792   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
18793   std::size_t arg2 ;
18794   Dali::MouseButton::Type result;
18795
18796   arg1 = (Dali::TouchEvent *)jarg1;
18797   arg2 = (std::size_t)jarg2;
18798   {
18799     try {
18800       result = ((Dali::TouchEvent const *)arg1)->GetMouseButton(arg2);
18801     } CALL_CATCH_EXCEPTION(0);
18802   }
18803
18804   jresult = static_cast< int >(result);
18805   return jresult;
18806 }
18807
18808
18809 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_0() {
18810   void * jresult ;
18811   Dali::GestureDetector *result = 0 ;
18812
18813   {
18814     try {
18815       result = (Dali::GestureDetector *)new Dali::GestureDetector();
18816     } CALL_CATCH_EXCEPTION(0);
18817   }
18818
18819   jresult = (void *)result;
18820   return jresult;
18821 }
18822
18823
18824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_DownCast(void * jarg1) {
18825   void * jresult ;
18826   Dali::BaseHandle arg1 ;
18827   Dali::BaseHandle *argp1 ;
18828   Dali::GestureDetector result;
18829
18830   argp1 = (Dali::BaseHandle *)jarg1;
18831   if (!argp1) {
18832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
18833     return 0;
18834   }
18835   arg1 = *argp1;
18836   {
18837     try {
18838       result = Dali::GestureDetector::DownCast(arg1);
18839     } CALL_CATCH_EXCEPTION(0);
18840   }
18841
18842   jresult = new Dali::GestureDetector((const Dali::GestureDetector &)result);
18843   return jresult;
18844 }
18845
18846
18847 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GestureDetector(void * jarg1) {
18848   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
18849
18850   arg1 = (Dali::GestureDetector *)jarg1;
18851   {
18852     try {
18853       delete arg1;
18854     } CALL_CATCH_EXCEPTION();
18855   }
18856
18857 }
18858
18859
18860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_1(void * jarg1) {
18861   void * jresult ;
18862   Dali::GestureDetector *arg1 = 0 ;
18863   Dali::GestureDetector *result = 0 ;
18864
18865   arg1 = (Dali::GestureDetector *)jarg1;
18866   if (!arg1) {
18867     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
18868     return 0;
18869   }
18870   {
18871     try {
18872       result = (Dali::GestureDetector *)new Dali::GestureDetector((Dali::GestureDetector const &)*arg1);
18873     } CALL_CATCH_EXCEPTION(0);
18874   }
18875
18876   jresult = (void *)result;
18877   return jresult;
18878 }
18879
18880
18881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_Assign(void * jarg1, void * jarg2) {
18882   void * jresult ;
18883   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
18884   Dali::GestureDetector *arg2 = 0 ;
18885   Dali::GestureDetector *result = 0 ;
18886
18887   arg1 = (Dali::GestureDetector *)jarg1;
18888   arg2 = (Dali::GestureDetector *)jarg2;
18889   if (!arg2) {
18890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
18891     return 0;
18892   }
18893   {
18894     try {
18895       result = (Dali::GestureDetector *) &(arg1)->operator =((Dali::GestureDetector const &)*arg2);
18896     } CALL_CATCH_EXCEPTION(0);
18897   }
18898
18899   jresult = (void *)result;
18900   return jresult;
18901 }
18902
18903
18904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Attach(void * jarg1, void * jarg2) {
18905   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
18906   Dali::Actor arg2 ;
18907   Dali::Actor *argp2 ;
18908
18909   arg1 = (Dali::GestureDetector *)jarg1;
18910   argp2 = (Dali::Actor *)jarg2;
18911   if (!argp2) {
18912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
18913     return ;
18914   }
18915   arg2 = *argp2;
18916   {
18917     try {
18918       (arg1)->Attach(arg2);
18919     } CALL_CATCH_EXCEPTION();
18920   }
18921
18922 }
18923
18924
18925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Detach(void * jarg1, void * jarg2) {
18926   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
18927   Dali::Actor arg2 ;
18928   Dali::Actor *argp2 ;
18929
18930   arg1 = (Dali::GestureDetector *)jarg1;
18931   argp2 = (Dali::Actor *)jarg2;
18932   if (!argp2) {
18933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
18934     return ;
18935   }
18936   arg2 = *argp2;
18937   {
18938     try {
18939       (arg1)->Detach(arg2);
18940     } CALL_CATCH_EXCEPTION();
18941   }
18942
18943 }
18944
18945
18946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_DetachAll(void * jarg1) {
18947   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
18948
18949   arg1 = (Dali::GestureDetector *)jarg1;
18950   {
18951     try {
18952       (arg1)->DetachAll();
18953     } CALL_CATCH_EXCEPTION();
18954   }
18955
18956 }
18957
18958
18959 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActorCount(void * jarg1) {
18960   unsigned long jresult ;
18961   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
18962   size_t result;
18963
18964   arg1 = (Dali::GestureDetector *)jarg1;
18965   {
18966     try {
18967       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActorCount();
18968     } CALL_CATCH_EXCEPTION(0);
18969   }
18970
18971   jresult = (unsigned long)result;
18972   return jresult;
18973 }
18974
18975
18976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActor(void * jarg1, unsigned long jarg2) {
18977   void * jresult ;
18978   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
18979   size_t arg2 ;
18980   Dali::Actor result;
18981
18982   arg1 = (Dali::GestureDetector *)jarg1;
18983   arg2 = (size_t)jarg2;
18984   {
18985     try {
18986       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActor(arg2);
18987     } CALL_CATCH_EXCEPTION(0);
18988   }
18989
18990   jresult = new Dali::Actor((const Dali::Actor &)result);
18991   return jresult;
18992 }
18993
18994
18995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Gesture(void * jarg1) {
18996   void * jresult ;
18997   Dali::Gesture *arg1 = 0 ;
18998   Dali::Gesture *result = 0 ;
18999
19000   arg1 = (Dali::Gesture *)jarg1;
19001   if (!arg1) {
19002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
19003     return 0;
19004   }
19005   {
19006     try {
19007       result = (Dali::Gesture *)new Dali::Gesture((Dali::Gesture const &)*arg1);
19008     } CALL_CATCH_EXCEPTION(0);
19009   }
19010
19011   jresult = (void *)result;
19012   return jresult;
19013 }
19014
19015
19016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Gesture_Assign(void * jarg1, void * jarg2) {
19017   void * jresult ;
19018   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
19019   Dali::Gesture *arg2 = 0 ;
19020   Dali::Gesture *result = 0 ;
19021
19022   arg1 = (Dali::Gesture *)jarg1;
19023   arg2 = (Dali::Gesture *)jarg2;
19024   if (!arg2) {
19025     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
19026     return 0;
19027   }
19028   {
19029     try {
19030       result = (Dali::Gesture *) &(arg1)->operator =((Dali::Gesture const &)*arg2);
19031     } CALL_CATCH_EXCEPTION(0);
19032   }
19033
19034   jresult = (void *)result;
19035   return jresult;
19036 }
19037
19038
19039 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Gesture(void * jarg1) {
19040   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
19041
19042   arg1 = (Dali::Gesture *)jarg1;
19043   {
19044     try {
19045       delete arg1;
19046     } CALL_CATCH_EXCEPTION();
19047   }
19048
19049 }
19050
19051
19052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_type_set(void * jarg1, int jarg2) {
19053   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
19054   Dali::Gesture::Type arg2 ;
19055
19056   arg1 = (Dali::Gesture *)jarg1;
19057   arg2 = (Dali::Gesture::Type)jarg2;
19058   if (arg1) (arg1)->type = arg2;
19059 }
19060
19061
19062 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_type_get(void * jarg1) {
19063   int jresult ;
19064   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
19065   Dali::Gesture::Type result;
19066
19067   arg1 = (Dali::Gesture *)jarg1;
19068   result = (Dali::Gesture::Type) ((arg1)->type);
19069   jresult = (int)result;
19070   return jresult;
19071 }
19072
19073
19074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_state_set(void * jarg1, int jarg2) {
19075   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
19076   Dali::Gesture::State arg2 ;
19077
19078   arg1 = (Dali::Gesture *)jarg1;
19079   arg2 = (Dali::Gesture::State)jarg2;
19080   if (arg1) (arg1)->state = arg2;
19081 }
19082
19083
19084 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_state_get(void * jarg1) {
19085   int jresult ;
19086   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
19087   Dali::Gesture::State result;
19088
19089   arg1 = (Dali::Gesture *)jarg1;
19090   result = (Dali::Gesture::State) ((arg1)->state);
19091   jresult = (int)result;
19092   return jresult;
19093 }
19094
19095
19096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_time_set(void * jarg1, unsigned int jarg2) {
19097   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
19098   unsigned int arg2 ;
19099
19100   arg1 = (Dali::Gesture *)jarg1;
19101   arg2 = (unsigned int)jarg2;
19102   if (arg1) (arg1)->time = arg2;
19103 }
19104
19105
19106 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Gesture_time_get(void * jarg1) {
19107   unsigned int jresult ;
19108   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
19109   unsigned int result;
19110
19111   arg1 = (Dali::Gesture *)jarg1;
19112   result = (unsigned int) ((arg1)->time);
19113   jresult = result;
19114   return jresult;
19115 }
19116
19117
19118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_0() {
19119   void * jresult ;
19120   Dali::HoverEvent *result = 0 ;
19121
19122   {
19123     try {
19124       result = (Dali::HoverEvent *)new Dali::HoverEvent();
19125     } CALL_CATCH_EXCEPTION(0);
19126   }
19127
19128   jresult = (void *)result;
19129   return jresult;
19130 }
19131
19132
19133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_1(void * jarg1) {
19134   void * jresult ;
19135   Dali::HoverEvent *arg1 = 0 ;
19136   Dali::HoverEvent *result = 0 ;
19137
19138   arg1 = (Dali::HoverEvent *)jarg1;
19139   if (!arg1) {
19140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
19141     return 0;
19142   }
19143   {
19144     try {
19145       result = (Dali::HoverEvent *)new Dali::HoverEvent((Dali::HoverEvent const &)*arg1);
19146     } CALL_CATCH_EXCEPTION(0);
19147   }
19148
19149   jresult = (void *)result;
19150   return jresult;
19151 }
19152
19153
19154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Hover(void * jarg1) {
19155   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
19156
19157   arg1 = (Dali::HoverEvent *)jarg1;
19158   {
19159     try {
19160       delete arg1;
19161     } CALL_CATCH_EXCEPTION();
19162   }
19163
19164 }
19165
19166
19167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_Assign(void * jarg1, void * jarg2) {
19168   void * jresult ;
19169   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
19170   Dali::HoverEvent *arg2 = 0 ;
19171   Dali::HoverEvent *result = 0 ;
19172
19173   arg1 = (Dali::HoverEvent *)jarg1;
19174   arg2 = (Dali::HoverEvent *)jarg2;
19175   if (!arg2) {
19176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
19177     return 0;
19178   }
19179   {
19180     try {
19181       result = (Dali::HoverEvent *) &(arg1)->operator =((Dali::HoverEvent const &)*arg2);
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 = (void *)result;
19202   return jresult;
19203 }
19204
19205
19206 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_GetTime(void * jarg1) {
19207   unsigned long jresult ;
19208   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
19209   unsigned long result;
19210
19211   arg1 = (Dali::HoverEvent *)jarg1;
19212   {
19213     try {
19214       result = (unsigned long)((Dali::HoverEvent const *)arg1)->GetTime();
19215     } catch (std::out_of_range& e) {
19216       {
19217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19218       };
19219     } catch (std::exception& e) {
19220       {
19221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19222       };
19223     } catch (Dali::DaliException e) {
19224       {
19225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19226       };
19227     } catch (...) {
19228       {
19229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19230       };
19231     }
19232   }
19233
19234   jresult = (unsigned long)result;
19235   return jresult;
19236 }
19237
19238
19239 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_GetPointCount(void * jarg1) {
19240   unsigned long jresult ;
19241   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
19242   std::size_t result;
19243
19244   arg1 = (Dali::HoverEvent *)jarg1;
19245   {
19246     try {
19247       result = ((Dali::HoverEvent const *)arg1)->GetPointCount();
19248     } catch (std::out_of_range& e) {
19249       {
19250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19251       };
19252     } catch (std::exception& e) {
19253       {
19254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19255       };
19256     } catch (Dali::DaliException e) {
19257       {
19258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19259       };
19260     } catch (...) {
19261       {
19262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19263       };
19264     }
19265   }
19266
19267   jresult = (unsigned long)result;
19268   return jresult;
19269 }
19270
19271
19272 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Hover_GetDeviceId(void * jarg1, unsigned long jarg2) {
19273   int jresult ;
19274   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
19275   std::size_t arg2 ;
19276   int32_t result;
19277
19278   arg1 = (Dali::HoverEvent *)jarg1;
19279   arg2 = (std::size_t)jarg2;
19280   {
19281     try {
19282       result = ((Dali::HoverEvent const *)arg1)->GetDeviceId(arg2);
19283     } catch (std::out_of_range& e) {
19284       {
19285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19286       };
19287     } catch (std::exception& e) {
19288       {
19289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19290       };
19291     } catch (Dali::DaliException e) {
19292       {
19293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19294       };
19295     } catch (...) {
19296       {
19297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19298       };
19299     }
19300   }
19301
19302   jresult = result;
19303   return jresult;
19304 }
19305
19306
19307 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Hover_GetState(void * jarg1, unsigned long jarg2) {
19308   int jresult ;
19309   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
19310   std::size_t arg2 ;
19311   Dali::PointState::Type result;
19312
19313   arg1 = (Dali::HoverEvent *)jarg1;
19314   arg2 = (std::size_t)jarg2;
19315   {
19316     try {
19317       result = (Dali::PointState::Type)((Dali::HoverEvent const *)arg1)->GetState(arg2);
19318     } CALL_CATCH_EXCEPTION(0);
19319   }
19320
19321   jresult = (int)result;
19322   return jresult;
19323 }
19324
19325
19326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetHitActor(void * jarg1, unsigned long jarg2) {
19327   void * jresult ;
19328   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
19329   std::size_t arg2 ;
19330   Dali::Actor result;
19331
19332   arg1 = (Dali::HoverEvent *)jarg1;
19333   arg2 = (std::size_t)jarg2;
19334   {
19335     try {
19336       result = ((Dali::HoverEvent const *)arg1)->GetHitActor(arg2);
19337     } catch (std::out_of_range& e) {
19338       {
19339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19340       };
19341     } catch (std::exception& e) {
19342       {
19343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19344       };
19345     } catch (Dali::DaliException e) {
19346       {
19347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19348       };
19349     } catch (...) {
19350       {
19351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19352       };
19353     }
19354   }
19355
19356   jresult = new Dali::Actor((const Dali::Actor &)result);
19357   return jresult;
19358 }
19359
19360
19361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetLocalPosition(void * jarg1, unsigned long jarg2) {
19362   void * jresult ;
19363   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
19364   std::size_t arg2 ;
19365   Dali::Vector2 *result = 0 ;
19366
19367   arg1 = (Dali::HoverEvent *)jarg1;
19368   arg2 = (std::size_t)jarg2;
19369   {
19370     try {
19371       result = (Dali::Vector2 *) &((Dali::HoverEvent const *)arg1)->GetLocalPosition(arg2);
19372     } catch (std::out_of_range& e) {
19373       {
19374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19375       };
19376     } catch (std::exception& e) {
19377       {
19378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19379       };
19380     } catch (Dali::DaliException e) {
19381       {
19382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19383       };
19384     } catch (...) {
19385       {
19386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19387       };
19388     }
19389   }
19390
19391   jresult = (void *)result;
19392   return jresult;
19393 }
19394
19395
19396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetScreenPosition(void * jarg1, unsigned long jarg2) {
19397   void * jresult ;
19398   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
19399   std::size_t arg2 ;
19400   Dali::Vector2 *result = 0 ;
19401
19402   arg1 = (Dali::HoverEvent *)jarg1;
19403   arg2 = (std::size_t)jarg2;
19404   {
19405     try {
19406       result = (Dali::Vector2 *) &((Dali::HoverEvent const *)arg1)->GetScreenPosition(arg2);
19407     } CALL_CATCH_EXCEPTION(0);
19408   }
19409
19410   jresult = (void *)result;
19411   return jresult;
19412 }
19413
19414
19415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_0() {
19416   void * jresult ;
19417   Dali::KeyEvent *result = 0 ;
19418
19419   {
19420     try {
19421       result = (Dali::KeyEvent *)new Dali::KeyEvent();
19422     } CALL_CATCH_EXCEPTION(0);
19423   }
19424
19425   jresult = (void *)result;
19426   return jresult;
19427 }
19428
19429
19430 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_1(void * jarg1) {
19431   void * jresult ;
19432   Dali::KeyEvent *arg1 = 0 ;
19433   Dali::KeyEvent *result = 0 ;
19434
19435   arg1 = (Dali::KeyEvent *)jarg1;
19436   if (!arg1) {
19437     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
19438     return 0;
19439   }
19440   {
19441     try {
19442       result = (Dali::KeyEvent *)new Dali::KeyEvent((Dali::KeyEvent const &)*arg1);
19443     } CALL_CATCH_EXCEPTION(0);
19444   }
19445
19446   jresult = (void *)result;
19447   return jresult;
19448 }
19449
19450
19451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_Assign(void * jarg1, void * jarg2) {
19452   void * jresult ;
19453   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
19454   Dali::KeyEvent *arg2 = 0 ;
19455   Dali::KeyEvent *result = 0 ;
19456
19457   arg1 = (Dali::KeyEvent *)jarg1;
19458   arg2 = (Dali::KeyEvent *)jarg2;
19459   if (!arg2) {
19460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
19461     return 0;
19462   }
19463   {
19464     try {
19465       result = (Dali::KeyEvent *) &(arg1)->operator =((Dali::KeyEvent const &)*arg2);
19466     } CALL_CATCH_EXCEPTION(0);
19467   }
19468
19469   jresult = (void *)result;
19470   return jresult;
19471 }
19472
19473
19474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_New(char * jarg1, char * jarg2, int jarg3, int jarg4, unsigned long jarg5, int jarg6) {
19475   void * jresult ;
19476   std::string *arg1 = 0 ;
19477   std::string *arg2 = 0 ;
19478   int arg3 ;
19479   int arg4 ;
19480   unsigned long arg5 ;
19481   Dali::KeyEvent::State *arg6 = 0 ;
19482   Dali::KeyEvent::State temp6 ;
19483   Dali::KeyEvent result;
19484
19485   if (!jarg1) {
19486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19487     return 0;
19488   }
19489   std::string arg1_str(jarg1);
19490   arg1 = &arg1_str;
19491   if (!jarg2) {
19492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19493     return 0;
19494   }
19495   std::string arg2_str(jarg2);
19496   arg2 = &arg2_str;
19497   arg3 = (int)jarg3;
19498   arg4 = (int)jarg4;
19499   arg5 = (unsigned long)jarg5;
19500   temp6 = (Dali::KeyEvent::State)jarg6;
19501   arg6 = &temp6;
19502   {
19503     try {
19504       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);
19505     } CALL_CATCH_EXCEPTION(0);
19506   }
19507
19508   jresult = new Dali::KeyEvent((const Dali::KeyEvent &)result);
19509
19510   //argout typemap for const std::string&
19511
19512
19513   //argout typemap for const std::string&
19514
19515   return jresult;
19516 }
19517
19518 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Key(void * jarg1) {
19519   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
19520
19521   arg1 = (Dali::KeyEvent *)jarg1;
19522   {
19523     try {
19524       delete arg1;
19525     } CALL_CATCH_EXCEPTION();
19526   }
19527
19528 }
19529
19530
19531 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsShiftModifier(void * jarg1) {
19532   unsigned int jresult ;
19533   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
19534   bool result;
19535
19536   arg1 = (Dali::KeyEvent *)jarg1;
19537   {
19538     try {
19539       result = (bool)((Dali::KeyEvent const *)arg1)->IsShiftModifier();
19540     } CALL_CATCH_EXCEPTION(0);
19541   }
19542
19543   jresult = result;
19544   return jresult;
19545 }
19546
19547
19548 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsCtrlModifier(void * jarg1) {
19549   unsigned int jresult ;
19550   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
19551   bool result;
19552
19553   arg1 = (Dali::KeyEvent *)jarg1;
19554   {
19555     try {
19556       result = (bool)((Dali::KeyEvent const *)arg1)->IsCtrlModifier();
19557     } CALL_CATCH_EXCEPTION(0);
19558   }
19559
19560   jresult = result;
19561   return jresult;
19562 }
19563
19564
19565 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsAltModifier(void * jarg1) {
19566   unsigned int jresult ;
19567   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
19568   bool result;
19569
19570   arg1 = (Dali::KeyEvent *)jarg1;
19571   {
19572     try {
19573       result = (bool)((Dali::KeyEvent const *)arg1)->IsAltModifier();
19574     } CALL_CATCH_EXCEPTION(0);
19575   }
19576
19577   jresult = result;
19578   return jresult;
19579 }
19580
19581
19582 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressedName_set(void * jarg1, char * jarg2) {
19583   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0 ;
19584   std::string *arg2 = 0 ;
19585
19586   Dali::KeyEvent arg1 = *argp1;
19587   if (!jarg2) {
19588     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19589     return ;
19590   }
19591   std::string arg2_str(jarg2);
19592   arg2 = &arg2_str;
19593
19594   {
19595     try {
19596       Dali::DevelKeyEvent::SetKeyName(arg1, (std::string const &)*arg2);
19597     } catch (std::out_of_range& e) {
19598       {
19599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19600       };
19601     } catch (std::exception& e) {
19602       {
19603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19604       };
19605     } catch (Dali::DaliException e) {
19606       {
19607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19608       };
19609     } catch (...) {
19610       {
19611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19612       };
19613     }
19614   }
19615 }
19616
19617
19618 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressedName_get(void * jarg1) {
19619   char * jresult ;
19620
19621   if( jarg1 == NULL )
19622   {
19623     jresult = SWIG_csharp_string_callback( "" );
19624   }
19625   else
19626   {
19627     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
19628     std::string *result = 0;
19629
19630     arg1 = ( Dali::KeyEvent * )jarg1;
19631     {
19632       try {
19633         std::string str = ((Dali::KeyEvent const *)arg1)->GetKeyName();
19634         result = (std::string *) &str;
19635       } catch (std::out_of_range& e) {
19636         {
19637           SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19638         };
19639       } catch (std::exception& e) {
19640         {
19641           SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19642         };
19643       } catch (Dali::DaliException e) {
19644         {
19645           SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19646         };
19647       } catch (...) {
19648         {
19649           SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19650         };
19651       }
19652     }
19653
19654     jresult = SWIG_csharp_string_callback(result->c_str());
19655   }
19656
19657   return jresult;
19658 }
19659
19660
19661 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressed_set(void * jarg1, char * jarg2) {
19662   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0 ;
19663   std::string *arg2 = 0 ;
19664
19665   Dali::KeyEvent arg1 = *argp1;
19666   if (!jarg2) {
19667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19668     return ;
19669   }
19670   std::string arg2_str(jarg2);
19671   arg2 = &arg2_str;
19672
19673   {
19674     try {
19675       Dali::DevelKeyEvent::SetKeyString(arg1, (std::string const &)*arg2);
19676     } catch (std::out_of_range& e) {
19677       {
19678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19679       };
19680     } catch (std::exception& e) {
19681       {
19682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19683       };
19684     } catch (Dali::DaliException e) {
19685       {
19686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19687       };
19688     } catch (...) {
19689       {
19690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19691       };
19692     }
19693   }
19694 }
19695
19696
19697 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressed_get(void * jarg1) {
19698   char * jresult ;
19699
19700   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
19701   std::string *result = 0;
19702
19703   arg1 = ( Dali::KeyEvent * )jarg1;
19704   {
19705     try {
19706       std::string str = ((Dali::KeyEvent const *)arg1)->GetKeyString();
19707       result = (std::string *) &str;
19708     } catch (std::out_of_range& e) {
19709       {
19710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19711       };
19712     } catch (std::exception& e) {
19713       {
19714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19715       };
19716     } catch (Dali::DaliException e) {
19717       {
19718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19719       };
19720     } catch (...) {
19721       {
19722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19723       };
19724     }
19725
19726     jresult = SWIG_csharp_string_callback(result->c_str());
19727   }
19728
19729   return jresult;
19730 }
19731
19732
19733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyCode_set(void * jarg1, int jarg2) {
19734   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0 ;
19735   int arg2 ;
19736
19737   Dali::KeyEvent arg1 = *argp1;
19738   arg2 = (int)jarg2;
19739   {
19740     try {
19741       Dali::DevelKeyEvent::SetKeyCode(arg1, arg2);
19742     } catch (std::out_of_range& e) {
19743       {
19744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19745       };
19746     } catch (std::exception& e) {
19747       {
19748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19749       };
19750     } catch (Dali::DaliException e) {
19751       {
19752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19753       };
19754     } catch (...) {
19755       {
19756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19757       };
19758     }
19759   }
19760 }
19761
19762
19763 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyCode_get(void * jarg1) {
19764   int jresult ;
19765   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
19766   int result;
19767
19768   arg1 = (Dali::KeyEvent *)jarg1;
19769   {
19770     try {
19771       result = (int)((Dali::KeyEvent const *)arg1)->GetKeyCode();
19772     } catch (std::out_of_range& e) {
19773       {
19774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19775       };
19776     } catch (std::exception& e) {
19777       {
19778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19779       };
19780     } catch (Dali::DaliException e) {
19781       {
19782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19783       };
19784     } catch (...) {
19785       {
19786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19787       };
19788     }
19789   }
19790
19791   jresult = result;
19792   return jresult;
19793 }
19794
19795
19796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyModifier_set(void * jarg1, int jarg2) {
19797   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0 ;
19798   int arg2 ;
19799
19800   Dali::KeyEvent arg1 = *argp1;
19801   arg2 = (int)jarg2;
19802   {
19803     try {
19804       Dali::DevelKeyEvent::SetKeyModifier(arg1, arg2);
19805     } catch (std::out_of_range& e) {
19806       {
19807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19808       };
19809     } catch (std::exception& e) {
19810       {
19811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19812       };
19813     } catch (Dali::DaliException e) {
19814       {
19815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19816       };
19817     } catch (...) {
19818       {
19819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19820       };
19821     }
19822   }
19823 }
19824
19825
19826 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyModifier_get(void * jarg1) {
19827   int jresult ;
19828   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
19829   int result;
19830
19831   arg1 = (Dali::KeyEvent *)jarg1;
19832   {
19833     try {
19834       result = (int)((Dali::KeyEvent const *)arg1)->GetKeyModifier();
19835     } catch (std::out_of_range& e) {
19836       {
19837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19838       };
19839     } catch (std::exception& e) {
19840       {
19841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19842       };
19843     } catch (Dali::DaliException e) {
19844       {
19845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19846       };
19847     } catch (...) {
19848       {
19849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19850       };
19851     }
19852   }
19853
19854   jresult = result;
19855   return jresult;
19856 }
19857
19858
19859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_time_set(void * jarg1, unsigned long jarg2) {
19860   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0 ;
19861   unsigned long arg2 ;
19862
19863   Dali::KeyEvent arg1 = *argp1;
19864   arg2 = (int)jarg2;
19865   {
19866     try {
19867       Dali::DevelKeyEvent::SetTime(arg1, arg2);
19868     } catch (std::out_of_range& e) {
19869       {
19870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19871       };
19872     } catch (std::exception& e) {
19873       {
19874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19875       };
19876     } catch (Dali::DaliException e) {
19877       {
19878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19879       };
19880     } catch (...) {
19881       {
19882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19883       };
19884     }
19885   }
19886 }
19887
19888
19889 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Key_time_get(void * jarg1) {
19890   unsigned long jresult ;
19891   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
19892   unsigned long result;
19893
19894   arg1 = (Dali::KeyEvent *)jarg1;
19895   {
19896     try {
19897       result = (int)((Dali::KeyEvent const *)arg1)->GetTime();
19898     } catch (std::out_of_range& e) {
19899       {
19900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19901       };
19902     } catch (std::exception& e) {
19903       {
19904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19905       };
19906     } catch (Dali::DaliException e) {
19907       {
19908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19909       };
19910     } catch (...) {
19911       {
19912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19913       };
19914     }
19915   }
19916
19917   jresult = result;
19918   return jresult;
19919 }
19920
19921
19922 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_state_set(void * jarg1, int jarg2) {
19923   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0;
19924   Dali::KeyEvent::State arg2;
19925
19926   Dali::KeyEvent arg1 = *argp1;
19927   arg2 = (Dali::KeyEvent::State)jarg2;
19928   {
19929     try {
19930       Dali::DevelKeyEvent::SetState(arg1, arg2);
19931     } catch (std::out_of_range& e) {
19932       {
19933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19934       };
19935     } catch (std::exception& e) {
19936       {
19937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19938       };
19939     } catch (Dali::DaliException e) {
19940       {
19941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19942       };
19943     } catch (...) {
19944       {
19945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19946       };
19947     }
19948   }
19949 }
19950
19951
19952 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_state_get(void * jarg1) {
19953   int jresult ;
19954   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
19955   Dali::KeyEvent::State result;
19956
19957   arg1 = (Dali::KeyEvent *)jarg1;
19958   {
19959     try {
19960       result = (Dali::KeyEvent::State)((Dali::KeyEvent const *)arg1)->GetState();
19961     } catch (std::out_of_range& e) {
19962       {
19963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19964       };
19965     } catch (std::exception& e) {
19966       {
19967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19968       };
19969     } catch (Dali::DaliException e) {
19970       {
19971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19972       };
19973     } catch (...) {
19974       {
19975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19976       };
19977     }
19978   }
19979
19980   jresult = (int)result;
19981   return jresult;
19982
19983 }
19984
19985 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_logicalKey_get(void * jarg1) {
19986   char * jresult ;
19987
19988   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
19989   std::string *result = 0;
19990
19991   arg1 = ( Dali::KeyEvent * )jarg1;
19992   {
19993     try {
19994       std::string str = ((Dali::KeyEvent const *)arg1)->GetLogicalKey();
19995       result = (std::string *) &str;
19996     } CALL_CATCH_EXCEPTION(0);
19997
19998   }
19999
20000   jresult = SWIG_csharp_string_callback(result->c_str());
20001   return jresult;
20002 }
20003
20004
20005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_0() {
20006   void * jresult ;
20007   Dali::LongPressGestureDetector *result = 0 ;
20008
20009   {
20010     try {
20011       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector();
20012     } CALL_CATCH_EXCEPTION(0);
20013   }
20014
20015   jresult = (void *)result;
20016   return jresult;
20017 }
20018
20019
20020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_0() {
20021   void * jresult ;
20022   Dali::LongPressGestureDetector result;
20023
20024   {
20025     try {
20026       result = Dali::LongPressGestureDetector::New();
20027     } CALL_CATCH_EXCEPTION(0);
20028   }
20029
20030   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
20031   return jresult;
20032 }
20033
20034
20035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_1(unsigned int jarg1) {
20036   void * jresult ;
20037   unsigned int arg1 ;
20038   Dali::LongPressGestureDetector result;
20039
20040   arg1 = (unsigned int)jarg1;
20041   {
20042     try {
20043       result = Dali::LongPressGestureDetector::New(arg1);
20044     } CALL_CATCH_EXCEPTION(0);
20045   }
20046
20047   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
20048   return jresult;
20049 }
20050
20051
20052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
20053   void * jresult ;
20054   unsigned int arg1 ;
20055   unsigned int arg2 ;
20056   Dali::LongPressGestureDetector result;
20057
20058   arg1 = (unsigned int)jarg1;
20059   arg2 = (unsigned int)jarg2;
20060   {
20061     try {
20062       result = Dali::LongPressGestureDetector::New(arg1,arg2);
20063     } CALL_CATCH_EXCEPTION(0);
20064   }
20065
20066   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
20067   return jresult;
20068 }
20069
20070
20071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DownCast(void * jarg1) {
20072   void * jresult ;
20073   Dali::BaseHandle arg1 ;
20074   Dali::BaseHandle *argp1 ;
20075   Dali::LongPressGestureDetector result;
20076
20077   argp1 = (Dali::BaseHandle *)jarg1;
20078   if (!argp1) {
20079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
20080     return 0;
20081   }
20082   arg1 = *argp1;
20083   {
20084     try {
20085       result = Dali::LongPressGestureDetector::DownCast(arg1);
20086     } CALL_CATCH_EXCEPTION(0);
20087   }
20088
20089   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
20090   return jresult;
20091 }
20092
20093
20094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetector(void * jarg1) {
20095   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
20096
20097   arg1 = (Dali::LongPressGestureDetector *)jarg1;
20098   {
20099     try {
20100       delete arg1;
20101     } CALL_CATCH_EXCEPTION();
20102   }
20103
20104 }
20105
20106
20107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_1(void * jarg1) {
20108   void * jresult ;
20109   Dali::LongPressGestureDetector *arg1 = 0 ;
20110   Dali::LongPressGestureDetector *result = 0 ;
20111
20112   arg1 = (Dali::LongPressGestureDetector *)jarg1;
20113   if (!arg1) {
20114     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
20115     return 0;
20116   }
20117   {
20118     try {
20119       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector((Dali::LongPressGestureDetector const &)*arg1);
20120     } CALL_CATCH_EXCEPTION(0);
20121   }
20122
20123   jresult = (void *)result;
20124   return jresult;
20125 }
20126
20127
20128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_Assign(void * jarg1, void * jarg2) {
20129   void * jresult ;
20130   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
20131   Dali::LongPressGestureDetector *arg2 = 0 ;
20132   Dali::LongPressGestureDetector *result = 0 ;
20133
20134   arg1 = (Dali::LongPressGestureDetector *)jarg1;
20135   arg2 = (Dali::LongPressGestureDetector *)jarg2;
20136   if (!arg2) {
20137     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
20138     return 0;
20139   }
20140   {
20141     try {
20142       result = (Dali::LongPressGestureDetector *) &(arg1)->operator =((Dali::LongPressGestureDetector const &)*arg2);
20143     } CALL_CATCH_EXCEPTION(0);
20144   }
20145
20146   jresult = (void *)result;
20147   return jresult;
20148 }
20149
20150
20151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_0(void * jarg1, unsigned int jarg2) {
20152   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
20153   unsigned int arg2 ;
20154
20155   arg1 = (Dali::LongPressGestureDetector *)jarg1;
20156   arg2 = (unsigned int)jarg2;
20157   {
20158     try {
20159       (arg1)->SetTouchesRequired(arg2);
20160     } CALL_CATCH_EXCEPTION();
20161   }
20162
20163 }
20164
20165
20166 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
20167   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
20168   unsigned int arg2 ;
20169   unsigned int arg3 ;
20170
20171   arg1 = (Dali::LongPressGestureDetector *)jarg1;
20172   arg2 = (unsigned int)jarg2;
20173   arg3 = (unsigned int)jarg3;
20174   {
20175     try {
20176       (arg1)->SetTouchesRequired(arg2,arg3);
20177     } CALL_CATCH_EXCEPTION();
20178   }
20179
20180 }
20181
20182
20183 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
20184   unsigned int jresult ;
20185   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
20186   unsigned int result;
20187
20188   arg1 = (Dali::LongPressGestureDetector *)jarg1;
20189   {
20190     try {
20191       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMinimumTouchesRequired();
20192     } CALL_CATCH_EXCEPTION(0);
20193   }
20194
20195   jresult = result;
20196   return jresult;
20197 }
20198
20199
20200 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
20201   unsigned int jresult ;
20202   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
20203   unsigned int result;
20204
20205   arg1 = (Dali::LongPressGestureDetector *)jarg1;
20206   {
20207     try {
20208       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMaximumTouchesRequired();
20209     } CALL_CATCH_EXCEPTION(0);
20210   }
20211
20212   jresult = result;
20213   return jresult;
20214 }
20215
20216
20217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DetectedSignal(void * jarg1) {
20218   void * jresult ;
20219   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
20220   Dali::LongPressGestureDetector::DetectedSignalType *result = 0 ;
20221
20222   arg1 = (Dali::LongPressGestureDetector *)jarg1;
20223   {
20224     try {
20225       result = (Dali::LongPressGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
20226     } CALL_CATCH_EXCEPTION(0);
20227   }
20228
20229   jresult = (void *)result;
20230   return jresult;
20231 }
20232
20233
20234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_0(int jarg1) {
20235   void * jresult ;
20236   Dali::Gesture::State arg1 ;
20237   Dali::LongPressGesture *result = 0 ;
20238
20239   arg1 = (Dali::Gesture::State)jarg1;
20240   {
20241     try {
20242       result = (Dali::LongPressGesture *)new Dali::LongPressGesture(arg1);
20243     } CALL_CATCH_EXCEPTION(0);
20244   }
20245
20246   jresult = (void *)result;
20247   return jresult;
20248 }
20249
20250
20251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_1(void * jarg1) {
20252   void * jresult ;
20253   Dali::LongPressGesture *arg1 = 0 ;
20254   Dali::LongPressGesture *result = 0 ;
20255
20256   arg1 = (Dali::LongPressGesture *)jarg1;
20257   if (!arg1) {
20258     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
20259     return 0;
20260   }
20261   {
20262     try {
20263       result = (Dali::LongPressGesture *)new Dali::LongPressGesture((Dali::LongPressGesture const &)*arg1);
20264     } CALL_CATCH_EXCEPTION(0);
20265   }
20266
20267   jresult = (void *)result;
20268   return jresult;
20269 }
20270
20271
20272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_Assign(void * jarg1, void * jarg2) {
20273   void * jresult ;
20274   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
20275   Dali::LongPressGesture *arg2 = 0 ;
20276   Dali::LongPressGesture *result = 0 ;
20277
20278   arg1 = (Dali::LongPressGesture *)jarg1;
20279   arg2 = (Dali::LongPressGesture *)jarg2;
20280   if (!arg2) {
20281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
20282     return 0;
20283   }
20284   {
20285     try {
20286       result = (Dali::LongPressGesture *) &(arg1)->operator =((Dali::LongPressGesture const &)*arg2);
20287     } CALL_CATCH_EXCEPTION(0);
20288   }
20289
20290   jresult = (void *)result;
20291   return jresult;
20292 }
20293
20294
20295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGesture(void * jarg1) {
20296   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
20297
20298   arg1 = (Dali::LongPressGesture *)jarg1;
20299   {
20300     try {
20301       delete arg1;
20302     } CALL_CATCH_EXCEPTION();
20303   }
20304
20305 }
20306
20307
20308 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
20309   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
20310   unsigned int arg2 ;
20311
20312   arg1 = (Dali::LongPressGesture *)jarg1;
20313   arg2 = (unsigned int)jarg2;
20314   if (arg1) (arg1)->numberOfTouches = arg2;
20315 }
20316
20317
20318 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_get(void * jarg1) {
20319   unsigned int jresult ;
20320   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
20321   unsigned int result;
20322
20323   arg1 = (Dali::LongPressGesture *)jarg1;
20324   result = (unsigned int) ((arg1)->numberOfTouches);
20325   jresult = result;
20326   return jresult;
20327 }
20328
20329
20330 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_set(void * jarg1, void * jarg2) {
20331   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
20332   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
20333
20334   arg1 = (Dali::LongPressGesture *)jarg1;
20335   arg2 = (Dali::Vector2 *)jarg2;
20336   if (arg1) (arg1)->screenPoint = *arg2;
20337 }
20338
20339
20340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_get(void * jarg1) {
20341   void * jresult ;
20342   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
20343   Dali::Vector2 *result = 0 ;
20344
20345   arg1 = (Dali::LongPressGesture *)jarg1;
20346   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
20347   jresult = (void *)result;
20348   return jresult;
20349 }
20350
20351
20352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_set(void * jarg1, void * jarg2) {
20353   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
20354   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
20355
20356   arg1 = (Dali::LongPressGesture *)jarg1;
20357   arg2 = (Dali::Vector2 *)jarg2;
20358   if (arg1) (arg1)->localPoint = *arg2;
20359 }
20360
20361
20362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_get(void * jarg1) {
20363   void * jresult ;
20364   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
20365   Dali::Vector2 *result = 0 ;
20366
20367   arg1 = (Dali::LongPressGesture *)jarg1;
20368   result = (Dali::Vector2 *)& ((arg1)->localPoint);
20369   jresult = (void *)result;
20370   return jresult;
20371 }
20372
20373
20374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_0() {
20375   void * jresult ;
20376   Dali::WheelEvent *result = 0 ;
20377
20378   {
20379     try {
20380       result = (Dali::WheelEvent *)new Dali::WheelEvent();
20381     } CALL_CATCH_EXCEPTION(0);
20382   }
20383
20384   jresult = (void *)result;
20385   return jresult;
20386 }
20387
20388
20389 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_1(void * jarg1) {
20390   void * jresult ;
20391   Dali::WheelEvent *arg1 = 0 ;
20392   Dali::WheelEvent *result = 0 ;
20393
20394   arg1 = (Dali::WheelEvent *)jarg1;
20395   if (!arg1) {
20396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
20397     return 0;
20398   }
20399   {
20400     try {
20401       result = (Dali::WheelEvent *)new Dali::WheelEvent((Dali::WheelEvent const &)*arg1);
20402     } catch (std::out_of_range& e) {
20403       {
20404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20405       };
20406     } catch (std::exception& e) {
20407       {
20408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20409       };
20410     } catch (Dali::DaliException e) {
20411       {
20412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20413       };
20414     } catch (...) {
20415       {
20416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20417       };
20418     }
20419   }
20420
20421   jresult = (void *)result;
20422   return jresult;
20423 }
20424
20425
20426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_Assign(void * jarg1, void * jarg2) {
20427   void * jresult ;
20428   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
20429   Dali::WheelEvent *arg2 = 0 ;
20430   Dali::WheelEvent *result = 0 ;
20431
20432   arg1 = (Dali::WheelEvent *)jarg1;
20433   arg2 = (Dali::WheelEvent *)jarg2;
20434   if (!arg2) {
20435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
20436     return 0;
20437   }
20438   {
20439     try {
20440       result = (Dali::WheelEvent *) &(arg1)->operator =((Dali::WheelEvent const &)*arg2);
20441     } catch (std::out_of_range& e) {
20442       {
20443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20444       };
20445     } catch (std::exception& e) {
20446       {
20447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20448       };
20449     } catch (Dali::DaliException e) {
20450       {
20451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20452       };
20453     } catch (...) {
20454       {
20455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20456       };
20457     }
20458   }
20459
20460   jresult = (void *)result;
20461   return jresult;
20462 }
20463
20464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_New(int jarg1, int jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6) {
20465   void * jresult ;
20466   Dali::WheelEvent::Type arg1 ;
20467   int arg2 ;
20468   unsigned int arg3 ;
20469   Dali::Vector2 arg4 ;
20470   int arg5 ;
20471   unsigned int arg6 ;
20472   Dali::Vector2 *argp4 ;
20473   Dali::WheelEvent result;
20474
20475   arg1 = (Dali::WheelEvent::Type)jarg1;
20476   arg2 = (int)jarg2;
20477   arg3 = (unsigned int)jarg3;
20478   argp4 = (Dali::Vector2 *)jarg4;
20479   if (!argp4) {
20480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
20481     return 0;
20482   }
20483   arg4 = *argp4;
20484   arg5 = (int)jarg5;
20485   arg6 = (unsigned int)jarg6;
20486   {
20487     try {
20488       result = DevelWheelEvent::New(arg1,arg2,arg3,arg4,arg5,arg6);
20489     } CALL_CATCH_EXCEPTION(0);
20490   }
20491
20492   jresult = new Dali::WheelEvent((const Dali::WheelEvent &)result);
20493   return jresult;
20494 }
20495
20496
20497 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Wheel(void * jarg1) {
20498   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
20499
20500   arg1 = (Dali::WheelEvent *)jarg1;
20501   {
20502     try {
20503       delete arg1;
20504     } CALL_CATCH_EXCEPTION();
20505   }
20506
20507 }
20508
20509
20510 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsShiftModifier(void * jarg1) {
20511   unsigned int jresult ;
20512   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
20513   bool result;
20514
20515   arg1 = (Dali::WheelEvent *)jarg1;
20516   {
20517     try {
20518       result = (bool)((Dali::WheelEvent const *)arg1)->IsShiftModifier();
20519     } CALL_CATCH_EXCEPTION(0);
20520   }
20521
20522   jresult = result;
20523   return jresult;
20524 }
20525
20526
20527 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsCtrlModifier(void * jarg1) {
20528   unsigned int jresult ;
20529   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
20530   bool result;
20531
20532   arg1 = (Dali::WheelEvent *)jarg1;
20533   {
20534     try {
20535       result = (bool)((Dali::WheelEvent const *)arg1)->IsCtrlModifier();
20536     } catch (std::out_of_range& e) {
20537       {
20538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20539       };
20540     } catch (std::exception& e) {
20541       {
20542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20543       };
20544     } catch (Dali::DaliException e) {
20545       {
20546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20547       };
20548     } catch (...) {
20549       {
20550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20551       };
20552     }
20553   }
20554
20555   jresult = result;
20556   return jresult;
20557 }
20558
20559
20560 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsAltModifier(void * jarg1) {
20561   unsigned int jresult ;
20562   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
20563   bool result;
20564
20565   arg1 = (Dali::WheelEvent *)jarg1;
20566   {
20567     try {
20568       result = (bool)((Dali::WheelEvent const *)arg1)->IsAltModifier();
20569     } catch (std::out_of_range& e) {
20570       {
20571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20572       };
20573     } catch (std::exception& e) {
20574       {
20575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20576       };
20577     } catch (Dali::DaliException e) {
20578       {
20579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20580       };
20581     } catch (...) {
20582       {
20583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20584       };
20585     }
20586   }
20587
20588   jresult = result;
20589   return jresult;
20590 }
20591
20592
20593 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_type_get(void * jarg1) {
20594   int jresult ;
20595   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
20596   Dali::WheelEvent::Type result;
20597
20598   arg1 = (Dali::WheelEvent *)jarg1;
20599   {
20600     try {
20601       result = ((Dali::WheelEvent const *)arg1)->GetType();
20602     } catch (std::out_of_range& e) {
20603       {
20604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20605       };
20606     } catch (std::exception& e) {
20607       {
20608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20609       };
20610     } catch (Dali::DaliException e) {
20611       {
20612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20613       };
20614     } catch (...) {
20615       {
20616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20617       };
20618     }
20619   }
20620
20621   jresult = (int)result;
20622   return jresult;
20623 }
20624
20625
20626 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_direction_get(void * jarg1) {
20627   int jresult ;
20628   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
20629   int result;
20630
20631   arg1 = (Dali::WheelEvent *)jarg1;
20632   {
20633     try {
20634       result = ((Dali::WheelEvent const *)arg1)->GetDirection();
20635     } catch (std::out_of_range& e) {
20636       {
20637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20638       };
20639     } catch (std::exception& e) {
20640       {
20641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20642       };
20643     } catch (Dali::DaliException e) {
20644       {
20645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20646       };
20647     } catch (...) {
20648       {
20649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20650       };
20651     }
20652   }
20653
20654   jresult = result;
20655   return jresult;
20656 }
20657
20658
20659 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_modifiers_get(void * jarg1) {
20660   unsigned int jresult ;
20661   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
20662   unsigned int result;
20663
20664   arg1 = (Dali::WheelEvent *)jarg1;
20665   {
20666     try {
20667       result = ((Dali::WheelEvent const *)arg1)->GetModifiers();
20668     } CALL_CATCH_EXCEPTION(0);
20669   }
20670
20671   jresult = result;
20672   return jresult;
20673 }
20674
20675
20676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_point_get(void * jarg1) {
20677   void * jresult ;
20678   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
20679   Dali::Vector2 *result = 0 ;
20680
20681   arg1 = (Dali::WheelEvent *)jarg1;
20682   {
20683     try {
20684       result = (Dali::Vector2 *) &((Dali::WheelEvent const *)arg1)->GetPoint();
20685     } CALL_CATCH_EXCEPTION(0);
20686   }
20687
20688   jresult = (void *)result;
20689   return jresult;
20690 }
20691
20692
20693 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_delta_get(void * jarg1) {
20694   int jresult ;
20695   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
20696   int result;
20697
20698   arg1 = (Dali::WheelEvent *)jarg1;
20699   {
20700     try {
20701       result = ((Dali::WheelEvent const *)arg1)->GetDelta();
20702     } catch (std::out_of_range& e) {
20703       {
20704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20705       };
20706     } catch (std::exception& e) {
20707       {
20708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20709       };
20710     } catch (Dali::DaliException e) {
20711       {
20712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20713       };
20714     } catch (...) {
20715       {
20716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20717       };
20718     }
20719   }
20720
20721   jresult = result;
20722   return jresult;
20723 }
20724
20725
20726 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_get(void * jarg1) {
20727   unsigned int jresult ;
20728   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
20729   unsigned int result;
20730
20731   arg1 = (Dali::WheelEvent *)jarg1;
20732   {
20733     try {
20734       result = ((Dali::WheelEvent const *)arg1)->GetTime();
20735     } catch (std::out_of_range& e) {
20736       {
20737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20738       };
20739     } catch (std::exception& e) {
20740       {
20741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20742       };
20743     } catch (Dali::DaliException e) {
20744       {
20745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20746       };
20747     } catch (...) {
20748       {
20749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20750       };
20751     }
20752   }
20753
20754   jresult = result;
20755   return jresult;
20756 }
20757
20758 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetDeviceName(void * jarg1) {
20759   char * jresult ;
20760   Dali::KeyEvent *arg1 = 0 ;
20761   std::string result;
20762
20763   arg1 = (Dali::KeyEvent *)jarg1;
20764   if (!arg1) {
20765     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
20766     return 0;
20767   }
20768   {
20769     try {
20770       result = arg1->GetDeviceName();
20771     } CALL_CATCH_EXCEPTION(0);
20772   }
20773
20774   jresult = SWIG_csharp_string_callback((&result)->c_str());
20775   return jresult;
20776 }
20777
20778 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceClass(void * jarg1) {
20779   int jresult ;
20780   Dali::KeyEvent *arg1 = 0 ;
20781   Dali::Device::Class::Type result;
20782
20783   arg1 = (Dali::KeyEvent *)jarg1;
20784   if (!arg1) {
20785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
20786     return 0;
20787   }
20788   {
20789     try {
20790       result = (Dali::Device::Class::Type)arg1->GetDeviceClass();
20791     } CALL_CATCH_EXCEPTION(0);
20792   }
20793
20794   jresult = (int)result;
20795   return jresult;
20796 }
20797
20798 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceSubClass(void * jarg1) {
20799   int jresult ;
20800   Dali::KeyEvent *arg1 = 0 ;
20801   Dali::Device::Subclass::Type result;
20802
20803   arg1 = (Dali::KeyEvent *)jarg1;
20804   if (!arg1) {
20805     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
20806     return 0;
20807   }
20808   {
20809     try {
20810       result = (Dali::Device::Subclass::Type)arg1->GetDeviceSubclass();
20811     } CALL_CATCH_EXCEPTION(0);
20812   }
20813
20814   jresult = (int)result;
20815   return jresult;
20816 }
20817
20818 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Raise(void * jarg1) {
20819   Dali::Actor arg1 ;
20820   Dali::Actor *argp1 ;
20821
20822   argp1 = (Dali::Actor *)jarg1;
20823   if (!argp1) {
20824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
20825     return ;
20826   }
20827   arg1 = *argp1;
20828   {
20829     try {
20830       arg1.Raise();
20831     } CALL_CATCH_EXCEPTION();
20832   }
20833
20834 }
20835
20836
20837 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Lower(void * jarg1) {
20838   Dali::Actor arg1 ;
20839   Dali::Actor *argp1 ;
20840
20841   argp1 = (Dali::Actor *)jarg1;
20842   if (!argp1) {
20843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
20844     return ;
20845   }
20846   arg1 = *argp1;
20847   {
20848     try {
20849       arg1.Lower();
20850     } CALL_CATCH_EXCEPTION();
20851   }
20852
20853 }
20854
20855
20856 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseToTop(void * jarg1) {
20857   Dali::Actor arg1 ;
20858   Dali::Actor *argp1 ;
20859
20860   argp1 = (Dali::Actor *)jarg1;
20861   if (!argp1) {
20862     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
20863     return ;
20864   }
20865   arg1 = *argp1;
20866   {
20867     try {
20868       arg1.RaiseToTop();
20869     } CALL_CATCH_EXCEPTION();
20870   }
20871
20872 }
20873
20874
20875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerToBottom(void * jarg1) {
20876   Dali::Actor arg1 ;
20877   Dali::Actor *argp1 ;
20878
20879   argp1 = (Dali::Actor *)jarg1;
20880   if (!argp1) {
20881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
20882     return ;
20883   }
20884   arg1 = *argp1;
20885   {
20886     try {
20887       arg1.LowerToBottom();
20888     } CALL_CATCH_EXCEPTION();
20889   }
20890
20891 }
20892
20893 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseAbove(void * jarg1, void * jarg2) {
20894   Dali::Actor arg1 ;
20895   Dali::Actor arg2 ;
20896   Dali::Actor *argp1 ;
20897   Dali::Actor *argp2 ;
20898
20899   argp1 = (Dali::Actor *)jarg1;
20900   if (!argp1) {
20901     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
20902     return ;
20903   }
20904   arg1 = *argp1;
20905   argp2 = (Dali::Actor *)jarg2;
20906   if (!argp2) {
20907     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
20908     return ;
20909   }
20910   arg2 = *argp2;
20911   {
20912     try {
20913       arg1.RaiseAbove(arg2);
20914     } CALL_CATCH_EXCEPTION();
20915   }
20916
20917 }
20918
20919
20920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerBelow(void * jarg1, void * jarg2) {
20921   Dali::Actor arg1 ;
20922   Dali::Actor arg2 ;
20923   Dali::Actor *argp1 ;
20924   Dali::Actor *argp2 ;
20925
20926   argp1 = (Dali::Actor *)jarg1;
20927   if (!argp1) {
20928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
20929     return ;
20930   }
20931   arg1 = *argp1;
20932   argp2 = (Dali::Actor *)jarg2;
20933   if (!argp2) {
20934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
20935     return ;
20936   }
20937   arg2 = *argp2;
20938   {
20939     try {
20940       arg1.LowerBelow(arg2);
20941     } CALL_CATCH_EXCEPTION();
20942   }
20943
20944 }
20945
20946
20947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisibilityChangedSignal(void * jarg1) {
20948   void * jresult ;
20949   Dali::Actor arg1 ;
20950   Dali::Actor *argp1 ;
20951   Dali::DevelActor::VisibilityChangedSignalType *result = 0 ;
20952
20953   argp1 = (Dali::Actor *)jarg1;
20954   if (!argp1) {
20955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
20956     return 0;
20957   }
20958   arg1 = *argp1;
20959   {
20960     try {
20961       result = (Dali::DevelActor::VisibilityChangedSignalType *) &Dali::DevelActor::VisibilityChangedSignal(arg1);
20962     } CALL_CATCH_EXCEPTION(0);
20963   }
20964
20965   jresult = (void *)result;
20966   return jresult;
20967 }
20968
20969
20970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutDirectionChangedSignal(void * jarg1) {
20971   void * jresult ;
20972   Dali::Actor *arg1 ;
20973   Dali::Actor::LayoutDirectionChangedSignalType *result = 0 ;
20974
20975   arg1 = (Dali::Actor *)jarg1;
20976   {
20977     try {
20978       result = (Dali::Actor::LayoutDirectionChangedSignalType *) &(arg1)->LayoutDirectionChangedSignal();
20979     } CALL_CATCH_EXCEPTION(0);
20980   }
20981
20982   jresult = (void *)result;
20983   return jresult;
20984 }
20985
20986
20987 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_get() {
20988   int jresult ;
20989   int result;
20990
20991   result = (int)Dali::Actor::Property::PARENT_ORIGIN;
20992   jresult = (int)result;
20993   return jresult;
20994 }
20995
20996
20997 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_X_get() {
20998   int jresult ;
20999   int result;
21000
21001   result = (int)Dali::Actor::Property::PARENT_ORIGIN_X;
21002   jresult = (int)result;
21003   return jresult;
21004 }
21005
21006
21007 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Y_get() {
21008   int jresult ;
21009   int result;
21010
21011   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Y;
21012   jresult = (int)result;
21013   return jresult;
21014 }
21015
21016
21017 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Z_get() {
21018   int jresult ;
21019   int result;
21020
21021   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Z;
21022   jresult = (int)result;
21023   return jresult;
21024 }
21025
21026
21027 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_get() {
21028   int jresult ;
21029   int result;
21030
21031   result = (int)Dali::Actor::Property::ANCHOR_POINT;
21032   jresult = (int)result;
21033   return jresult;
21034 }
21035
21036
21037 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_X_get() {
21038   int jresult ;
21039   int result;
21040
21041   result = (int)Dali::Actor::Property::ANCHOR_POINT_X;
21042   jresult = (int)result;
21043   return jresult;
21044 }
21045
21046
21047 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Y_get() {
21048   int jresult ;
21049   int result;
21050
21051   result = (int)Dali::Actor::Property::ANCHOR_POINT_Y;
21052   jresult = (int)result;
21053   return jresult;
21054 }
21055
21056
21057 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Z_get() {
21058   int jresult ;
21059   int result;
21060
21061   result = (int)Dali::Actor::Property::ANCHOR_POINT_Z;
21062   jresult = (int)result;
21063   return jresult;
21064 }
21065
21066
21067 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_get() {
21068   int jresult ;
21069   int result;
21070
21071   result = (int)Dali::Actor::Property::SIZE;
21072   jresult = (int)result;
21073   return jresult;
21074 }
21075
21076
21077 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_WIDTH_get() {
21078   int jresult ;
21079   int result;
21080
21081   result = (int)Dali::Actor::Property::SIZE_WIDTH;
21082   jresult = (int)result;
21083   return jresult;
21084 }
21085
21086
21087 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_HEIGHT_get() {
21088   int jresult ;
21089   int result;
21090
21091   result = (int)Dali::Actor::Property::SIZE_HEIGHT;
21092   jresult = (int)result;
21093   return jresult;
21094 }
21095
21096
21097 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_DEPTH_get() {
21098   int jresult ;
21099   int result;
21100
21101   result = (int)Dali::Actor::Property::SIZE_DEPTH;
21102   jresult = (int)result;
21103   return jresult;
21104 }
21105
21106
21107 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_get() {
21108   int jresult ;
21109   int result;
21110
21111   result = (int)Dali::Actor::Property::POSITION;
21112   jresult = (int)result;
21113   return jresult;
21114 }
21115
21116
21117 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_X_get() {
21118   int jresult ;
21119   int result;
21120
21121   result = (int)Dali::Actor::Property::POSITION_X;
21122   jresult = (int)result;
21123   return jresult;
21124 }
21125
21126
21127 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Y_get() {
21128   int jresult ;
21129   int result;
21130
21131   result = (int)Dali::Actor::Property::POSITION_Y;
21132   jresult = (int)result;
21133   return jresult;
21134 }
21135
21136
21137 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Z_get() {
21138   int jresult ;
21139   int result;
21140
21141   result = (int)Dali::Actor::Property::POSITION_Z;
21142   jresult = (int)result;
21143   return jresult;
21144 }
21145
21146
21147 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_get() {
21148   int jresult ;
21149   int result;
21150
21151   result = (int)Dali::Actor::Property::WORLD_POSITION;
21152   jresult = (int)result;
21153   return jresult;
21154 }
21155
21156
21157 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_X_get() {
21158   int jresult ;
21159   int result;
21160
21161   result = (int)Dali::Actor::Property::WORLD_POSITION_X;
21162   jresult = (int)result;
21163   return jresult;
21164 }
21165
21166
21167 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Y_get() {
21168   int jresult ;
21169   int result;
21170
21171   result = (int)Dali::Actor::Property::WORLD_POSITION_Y;
21172   jresult = (int)result;
21173   return jresult;
21174 }
21175
21176
21177 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Z_get() {
21178   int jresult ;
21179   int result;
21180
21181   result = (int)Dali::Actor::Property::WORLD_POSITION_Z;
21182   jresult = (int)result;
21183   return jresult;
21184 }
21185
21186
21187 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ORIENTATION_get() {
21188   int jresult ;
21189   int result;
21190
21191   result = (int)Dali::Actor::Property::ORIENTATION;
21192   jresult = (int)result;
21193   return jresult;
21194 }
21195
21196
21197 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_ORIENTATION_get() {
21198   int jresult ;
21199   int result;
21200
21201   result = (int)Dali::Actor::Property::WORLD_ORIENTATION;
21202   jresult = (int)result;
21203   return jresult;
21204 }
21205
21206
21207 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_get() {
21208   int jresult ;
21209   int result;
21210
21211   result = (int)Dali::Actor::Property::SCALE;
21212   jresult = (int)result;
21213   return jresult;
21214 }
21215
21216
21217 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_X_get() {
21218   int jresult ;
21219   int result;
21220
21221   result = (int)Dali::Actor::Property::SCALE_X;
21222   jresult = (int)result;
21223   return jresult;
21224 }
21225
21226
21227 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Y_get() {
21228   int jresult ;
21229   int result;
21230
21231   result = (int)Dali::Actor::Property::SCALE_Y;
21232   jresult = (int)result;
21233   return jresult;
21234 }
21235
21236
21237 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Z_get() {
21238   int jresult ;
21239   int result;
21240
21241   result = (int)Dali::Actor::Property::SCALE_Z;
21242   jresult = (int)result;
21243   return jresult;
21244 }
21245
21246
21247 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_SCALE_get() {
21248   int jresult ;
21249   int result;
21250
21251   result = (int)Dali::Actor::Property::WORLD_SCALE;
21252   jresult = (int)result;
21253   return jresult;
21254 }
21255
21256
21257 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_VISIBLE_get() {
21258   int jresult ;
21259   int result;
21260
21261   result = (int)Dali::Actor::Property::VISIBLE;
21262   jresult = (int)result;
21263   return jresult;
21264 }
21265
21266
21267 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_get() {
21268   int jresult ;
21269   int result;
21270
21271   result = (int)Dali::Actor::Property::COLOR;
21272   jresult = (int)result;
21273   return jresult;
21274 }
21275
21276
21277 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_RED_get() {
21278   int jresult ;
21279   int result;
21280
21281   result = (int)Dali::Actor::Property::COLOR_RED;
21282   jresult = (int)result;
21283   return jresult;
21284 }
21285
21286
21287 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_GREEN_get() {
21288   int jresult ;
21289   int result;
21290
21291   result = (int)Dali::Actor::Property::COLOR_GREEN;
21292   jresult = (int)result;
21293   return jresult;
21294 }
21295
21296
21297 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_BLUE_get() {
21298   int jresult ;
21299   int result;
21300
21301   result = (int)Dali::Actor::Property::COLOR_BLUE;
21302   jresult = (int)result;
21303   return jresult;
21304 }
21305
21306
21307 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_ALPHA_get() {
21308   int jresult ;
21309   int result;
21310
21311   result = (int)Dali::Actor::Property::COLOR_ALPHA;
21312   jresult = (int)result;
21313   return jresult;
21314 }
21315
21316
21317 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_COLOR_get() {
21318   int jresult ;
21319   int result;
21320
21321   result = (int)Dali::Actor::Property::WORLD_COLOR;
21322   jresult = (int)result;
21323   return jresult;
21324 }
21325
21326
21327 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_MATRIX_get() {
21328   int jresult ;
21329   int result;
21330
21331   result = (int)Dali::Actor::Property::WORLD_MATRIX;
21332   jresult = (int)result;
21333   return jresult;
21334 }
21335
21336
21337 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_NAME_get() {
21338   int jresult ;
21339   int result;
21340
21341   result = (int)Dali::Actor::Property::NAME;
21342   jresult = (int)result;
21343   return jresult;
21344 }
21345
21346
21347 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SENSITIVE_get() {
21348   int jresult ;
21349   int result;
21350
21351   result = (int)Dali::Actor::Property::SENSITIVE;
21352   jresult = (int)result;
21353   return jresult;
21354 }
21355
21356
21357 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_LEAVE_REQUIRED_get() {
21358   int jresult ;
21359   int result;
21360
21361   result = (int)Dali::Actor::Property::LEAVE_REQUIRED;
21362   jresult = (int)result;
21363   return jresult;
21364 }
21365
21366
21367 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_ORIENTATION_get() {
21368   int jresult ;
21369   int result;
21370
21371   result = (int)Dali::Actor::Property::INHERIT_ORIENTATION;
21372   jresult = (int)result;
21373   return jresult;
21374 }
21375
21376
21377 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_SCALE_get() {
21378   int jresult ;
21379   int result;
21380
21381   result = (int)Dali::Actor::Property::INHERIT_SCALE;
21382   jresult = (int)result;
21383   return jresult;
21384 }
21385
21386
21387 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_MODE_get() {
21388   int jresult ;
21389   int result;
21390
21391   result = (int)Dali::Actor::Property::COLOR_MODE;
21392   jresult = (int)result;
21393   return jresult;
21394 }
21395
21396
21397 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_DRAW_MODE_get() {
21398   int jresult ;
21399   int result;
21400
21401   result = (int)Dali::Actor::Property::DRAW_MODE;
21402   jresult = (int)result;
21403   return jresult;
21404 }
21405
21406
21407 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_MODE_FACTOR_get() {
21408   int jresult ;
21409   int result;
21410
21411   result = (int)Dali::Actor::Property::SIZE_MODE_FACTOR;
21412   jresult = (int)result;
21413   return jresult;
21414 }
21415
21416
21417 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_RESIZE_POLICY_get() {
21418   int jresult ;
21419   int result;
21420
21421   result = (int)Dali::Actor::Property::WIDTH_RESIZE_POLICY;
21422   jresult = (int)result;
21423   return jresult;
21424 }
21425
21426
21427 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_RESIZE_POLICY_get() {
21428   int jresult ;
21429   int result;
21430
21431   result = (int)Dali::Actor::Property::HEIGHT_RESIZE_POLICY;
21432   jresult = (int)result;
21433   return jresult;
21434 }
21435
21436
21437 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_SCALE_POLICY_get() {
21438   int jresult ;
21439   int result;
21440
21441   result = (int)Dali::Actor::Property::SIZE_SCALE_POLICY;
21442   jresult = (int)result;
21443   return jresult;
21444 }
21445
21446
21447 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_FOR_HEIGHT_get() {
21448   int jresult ;
21449   int result;
21450
21451   result = (int)Dali::Actor::Property::WIDTH_FOR_HEIGHT;
21452   jresult = (int)result;
21453   return jresult;
21454 }
21455
21456
21457 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_FOR_WIDTH_get() {
21458   int jresult ;
21459   int result;
21460
21461   result = (int)Dali::Actor::Property::HEIGHT_FOR_WIDTH;
21462   jresult = (int)result;
21463   return jresult;
21464 }
21465
21466
21467 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PADDING_get() {
21468   int jresult ;
21469   int result;
21470
21471   result = (int)Dali::Actor::Property::PADDING;
21472   jresult = (int)result;
21473   return jresult;
21474 }
21475
21476
21477 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MINIMUM_SIZE_get() {
21478   int jresult ;
21479   int result;
21480
21481   result = (int)Dali::Actor::Property::MINIMUM_SIZE;
21482   jresult = (int)result;
21483   return jresult;
21484 }
21485
21486
21487 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MAXIMUM_SIZE_get() {
21488   int jresult ;
21489   int result;
21490
21491   result = (int)Dali::Actor::Property::MAXIMUM_SIZE;
21492   jresult = (int)result;
21493   return jresult;
21494 }
21495
21496
21497 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_POSITION_get() {
21498   int jresult ;
21499   int result;
21500
21501   result = (int)Dali::Actor::Property::INHERIT_POSITION;
21502   jresult = (int)result;
21503   return jresult;
21504 }
21505
21506
21507 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CLIPPING_MODE_get() {
21508   int jresult ;
21509   int result;
21510
21511   result = (int)Dali::Actor::Property::CLIPPING_MODE;
21512   jresult = (int)result;
21513   return jresult;
21514 }
21515
21516 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_OPACITY_get() {
21517
21518   return Dali::Actor::Property::OPACITY;
21519 }
21520
21521 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_SCREEN_POSITION_get() {
21522
21523   return Dali::Actor::Property::SCREEN_POSITION;
21524 }
21525
21526 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_POSITION_USES_ANCHOR_POINT_get() {
21527
21528   return Dali::Actor::Property::POSITION_USES_ANCHOR_POINT;
21529 }
21530
21531 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_INHERIT_LAYOUT_DIRECTION_get() {
21532   return Dali::Actor::Property::INHERIT_LAYOUT_DIRECTION;
21533 }
21534
21535 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_LAYOUT_DIRECTION_get() {
21536   return Dali::Actor::Property::LAYOUT_DIRECTION;
21537 }
21538
21539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor_Property() {
21540   void * jresult ;
21541   Dali::Actor::Property *result = 0 ;
21542
21543   {
21544     try {
21545       result = (Dali::Actor::Property *)new Dali::Actor::Property();
21546     } CALL_CATCH_EXCEPTION(0);
21547   }
21548
21549   jresult = (void *)result;
21550   return jresult;
21551 }
21552
21553
21554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor_Property(void * jarg1) {
21555   Dali::Actor::Property *arg1 = (Dali::Actor::Property *) 0 ;
21556
21557   arg1 = (Dali::Actor::Property *)jarg1;
21558   {
21559     try {
21560       delete arg1;
21561     } CALL_CATCH_EXCEPTION();
21562   }
21563
21564 }
21565
21566
21567 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_0() {
21568   void * jresult ;
21569   Dali::Actor *result = 0 ;
21570
21571   {
21572     try {
21573       result = (Dali::Actor *)new Dali::Actor();
21574     } CALL_CATCH_EXCEPTION(0);
21575   }
21576
21577   jresult = (void *)result;
21578   return jresult;
21579 }
21580
21581
21582 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_New() {
21583   void * jresult ;
21584   Dali::Actor result;
21585
21586   {
21587     try {
21588       result = Dali::Actor::New();
21589     } CALL_CATCH_EXCEPTION(0);
21590   }
21591
21592   jresult = new Dali::Actor((const Dali::Actor &)result);
21593   return jresult;
21594 }
21595
21596
21597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_DownCast(void * jarg1) {
21598   void * jresult ;
21599   Dali::BaseHandle arg1 ;
21600   Dali::BaseHandle *argp1 ;
21601   Dali::Actor result;
21602
21603   argp1 = (Dali::BaseHandle *)jarg1;
21604   if (!argp1) {
21605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
21606     return 0;
21607   }
21608   arg1 = *argp1;
21609   {
21610     try {
21611       result = Dali::Actor::DownCast(arg1);
21612     } CALL_CATCH_EXCEPTION(0);
21613   }
21614
21615   jresult = new Dali::Actor((const Dali::Actor &)result);
21616   return jresult;
21617 }
21618
21619
21620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor(void * jarg1) {
21621   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21622
21623   arg1 = (Dali::Actor *)jarg1;
21624   {
21625     try {
21626       delete arg1;
21627     } CALL_CATCH_EXCEPTION();
21628   }
21629
21630 }
21631
21632
21633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_1(void * jarg1) {
21634   void * jresult ;
21635   Dali::Actor *arg1 = 0 ;
21636   Dali::Actor *result = 0 ;
21637
21638   arg1 = (Dali::Actor *)jarg1;
21639   if (!arg1) {
21640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
21641     return 0;
21642   }
21643   {
21644     try {
21645       result = (Dali::Actor *)new Dali::Actor((Dali::Actor const &)*arg1);
21646     } CALL_CATCH_EXCEPTION(0);
21647   }
21648
21649   jresult = (void *)result;
21650   return jresult;
21651 }
21652
21653
21654 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_Assign(void * jarg1, void * jarg2) {
21655   void * jresult ;
21656   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21657   Dali::Actor *arg2 = 0 ;
21658   Dali::Actor *result = 0 ;
21659
21660   arg1 = (Dali::Actor *)jarg1;
21661   arg2 = (Dali::Actor *)jarg2;
21662   if (!arg2) {
21663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
21664     return 0;
21665   }
21666   {
21667     try {
21668       result = (Dali::Actor *) &(arg1)->operator =((Dali::Actor const &)*arg2);
21669     } CALL_CATCH_EXCEPTION(0);
21670   }
21671
21672   jresult = (void *)result;
21673   return jresult;
21674 }
21675
21676
21677 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Actor_GetName(void * jarg1) {
21678   char * jresult ;
21679   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21680   std::string *result = 0 ;
21681   std::string name = "";
21682
21683   arg1 = (Dali::Actor *)jarg1;
21684   {
21685     try {
21686       name = ((Dali::Actor const *)arg1)->GetProperty< std::string >( Dali::Actor::Property::NAME );
21687       result = (std::string *) &name;
21688       jresult = SWIG_csharp_string_callback(result->c_str());
21689     } CALL_CATCH_EXCEPTION(0);
21690   }
21691   return jresult;
21692 }
21693
21694
21695 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetName(void * jarg1, char * jarg2) {
21696   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21697   std::string *arg2 = 0 ;
21698
21699   arg1 = (Dali::Actor *)jarg1;
21700   if (!jarg2) {
21701     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
21702     return ;
21703   }
21704   std::string arg2_str(jarg2);
21705   arg2 = &arg2_str;
21706   {
21707     try {
21708       (arg1)->SetProperty( Dali::Actor::Property::NAME, (std::string const &)*arg2);
21709     } CALL_CATCH_EXCEPTION();
21710   }
21711
21712
21713   //argout typemap for const std::string&
21714
21715 }
21716
21717
21718 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetId(void * jarg1) {
21719   unsigned int jresult ;
21720   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21721   unsigned int result;
21722
21723   arg1 = (Dali::Actor *)jarg1;
21724
21725   if(!arg1) {
21726     DALI_LOG_ERROR("[ERROR] actor is null! return -1");
21727     return -1;
21728   }
21729
21730   {
21731     try {
21732       result = (unsigned int)((Dali::Actor const *)arg1)->GetProperty< int >( Actor::Property::ID );
21733     } CALL_CATCH_EXCEPTION(0);
21734   }
21735
21736   jresult = result;
21737   return jresult;
21738 }
21739
21740
21741 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsRoot(void * jarg1) {
21742   unsigned int jresult ;
21743   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21744   bool result;
21745
21746   arg1 = (Dali::Actor *)jarg1;
21747   {
21748     try {
21749       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::IS_ROOT );
21750     } CALL_CATCH_EXCEPTION(0);
21751   }
21752
21753   jresult = result;
21754   return jresult;
21755 }
21756
21757
21758 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_OnStage(void * jarg1) {
21759   unsigned int jresult ;
21760   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21761   bool result;
21762
21763   arg1 = (Dali::Actor *)jarg1;
21764   {
21765     try {
21766       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::CONNECTED_TO_SCENE );
21767     } CALL_CATCH_EXCEPTION(0);
21768   }
21769
21770   jresult = result;
21771   return jresult;
21772 }
21773
21774
21775 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsLayer(void * jarg1) {
21776   unsigned int jresult ;
21777   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21778   bool result;
21779
21780   arg1 = (Dali::Actor *)jarg1;
21781   {
21782     try {
21783       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::IS_LAYER );
21784     } CALL_CATCH_EXCEPTION(0);
21785   }
21786
21787   jresult = result;
21788   return jresult;
21789 }
21790
21791
21792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetLayer(void * jarg1) {
21793   void * jresult ;
21794   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21795   Dali::Layer result;
21796
21797   arg1 = (Dali::Actor *)jarg1;
21798   {
21799     try {
21800       result = (arg1)->GetLayer();
21801     } CALL_CATCH_EXCEPTION(0);
21802   }
21803
21804   jresult = new Dali::Layer((const Dali::Layer &)result);
21805   return jresult;
21806 }
21807
21808
21809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Add(void * jarg1, void * jarg2) {
21810   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21811   Dali::Actor arg2 ;
21812   Dali::Actor *argp2 ;
21813
21814   arg1 = (Dali::Actor *)jarg1;
21815   argp2 = (Dali::Actor *)jarg2;
21816   if (!argp2) {
21817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
21818     return ;
21819   }
21820   arg2 = *argp2;
21821   {
21822     try {
21823       (arg1)->Add(arg2);
21824     } CALL_CATCH_EXCEPTION();
21825   }
21826
21827 }
21828
21829
21830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Remove(void * jarg1, void * jarg2) {
21831   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21832   Dali::Actor arg2 ;
21833   Dali::Actor *argp2 ;
21834
21835   arg1 = (Dali::Actor *)jarg1;
21836   argp2 = (Dali::Actor *)jarg2;
21837   if (!argp2) {
21838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
21839     return ;
21840   }
21841   arg2 = *argp2;
21842   {
21843     try {
21844       (arg1)->Remove(arg2);
21845     } CALL_CATCH_EXCEPTION();
21846   }
21847
21848 }
21849
21850
21851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Unparent(void * jarg1) {
21852   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21853
21854   arg1 = (Dali::Actor *)jarg1;
21855   {
21856     try {
21857       (arg1)->Unparent();
21858     } CALL_CATCH_EXCEPTION();
21859   }
21860
21861 }
21862
21863
21864 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetChildCount(void * jarg1) {
21865   unsigned int jresult ;
21866   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21867   unsigned int result;
21868
21869   arg1 = (Dali::Actor *)jarg1;
21870   {
21871     try {
21872       result = (unsigned int)((Dali::Actor const *)arg1)->GetChildCount();
21873     } CALL_CATCH_EXCEPTION(0);
21874   }
21875
21876   jresult = result;
21877   return jresult;
21878 }
21879
21880
21881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetChildAt(void * jarg1, unsigned int jarg2) {
21882   void * jresult ;
21883   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21884   unsigned int arg2 ;
21885   Dali::Actor result;
21886
21887   arg1 = (Dali::Actor *)jarg1;
21888   arg2 = (unsigned int)jarg2;
21889   {
21890     try {
21891       result = ((Dali::Actor const *)arg1)->GetChildAt(arg2);
21892     } CALL_CATCH_EXCEPTION(0);
21893   }
21894
21895   jresult = new Dali::Actor((const Dali::Actor &)result);
21896   return jresult;
21897 }
21898
21899
21900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildByName(void * jarg1, char * jarg2) {
21901   void * jresult ;
21902   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21903   std::string *arg2 = 0 ;
21904   Dali::Actor result;
21905
21906   arg1 = (Dali::Actor *)jarg1;
21907   if (!jarg2) {
21908     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
21909     return 0;
21910   }
21911   std::string arg2_str(jarg2);
21912   arg2 = &arg2_str;
21913   {
21914     try {
21915       result = (arg1)->FindChildByName((std::string const &)*arg2);
21916     } CALL_CATCH_EXCEPTION(0);
21917   }
21918
21919   jresult = new Dali::Actor((const Dali::Actor &)result);
21920
21921   //argout typemap for const std::string&
21922
21923   return jresult;
21924 }
21925
21926
21927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildById(void * jarg1, unsigned int jarg2) {
21928   void * jresult ;
21929   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21930   unsigned int arg2 ;
21931   Dali::Actor result;
21932
21933   arg1 = (Dali::Actor *)jarg1;
21934   arg2 = (unsigned int)jarg2;
21935   {
21936     try {
21937       result = (arg1)->FindChildById(arg2);
21938     } CALL_CATCH_EXCEPTION(0);
21939   }
21940
21941   jresult = new Dali::Actor((const Dali::Actor &)result);
21942   return jresult;
21943 }
21944
21945
21946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetParent(void * jarg1) {
21947   void * jresult ;
21948   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21949   Dali::Actor result;
21950
21951   arg1 = (Dali::Actor *)jarg1;
21952   {
21953     try {
21954       result = ((Dali::Actor const *)arg1)->GetParent();
21955     } CALL_CATCH_EXCEPTION(0);
21956   }
21957
21958   jresult = new Dali::Actor((const Dali::Actor &)result);
21959   return jresult;
21960 }
21961
21962
21963 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetParentOrigin(void * jarg1, void * jarg2) {
21964   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21965   Dali::Vector3 *arg2 = 0 ;
21966
21967   arg1 = (Dali::Actor *)jarg1;
21968   arg2 = (Dali::Vector3 *)jarg2;
21969   if (!arg2) {
21970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
21971     return ;
21972   }
21973   {
21974     try {
21975       (arg1)->SetProperty( Actor::Property::PARENT_ORIGIN,(Dali::Vector3 const &)*arg2);
21976     } CALL_CATCH_EXCEPTION();
21977   }
21978
21979 }
21980
21981
21982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentParentOrigin(void * jarg1) {
21983   void * jresult ;
21984   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21985   Dali::Vector3 result;
21986
21987   arg1 = (Dali::Actor *)jarg1;
21988   {
21989     try {
21990       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::PARENT_ORIGIN );
21991     } CALL_CATCH_EXCEPTION(0);
21992   }
21993
21994   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
21995   return jresult;
21996 }
21997
21998
21999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetAnchorPoint(void * jarg1, void * jarg2) {
22000   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22001   Dali::Vector3 *arg2 = 0 ;
22002
22003   arg1 = (Dali::Actor *)jarg1;
22004   arg2 = (Dali::Vector3 *)jarg2;
22005   if (!arg2) {
22006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
22007     return ;
22008   }
22009   {
22010     try {
22011       (arg1)->SetProperty( Actor::Property::ANCHOR_POINT,(Dali::Vector3 const &)*arg2);
22012     } CALL_CATCH_EXCEPTION();
22013   }
22014
22015 }
22016
22017
22018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentAnchorPoint(void * jarg1) {
22019   void * jresult ;
22020   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22021   Dali::Vector3 result;
22022
22023   arg1 = (Dali::Actor *)jarg1;
22024   {
22025     try {
22026       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::ANCHOR_POINT );
22027     } CALL_CATCH_EXCEPTION(0);
22028   }
22029
22030   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
22031   return jresult;
22032 }
22033
22034
22035 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_0(void * jarg1, float jarg2, float jarg3) {
22036   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22037   float arg2 ;
22038   float arg3 ;
22039
22040   arg1 = (Dali::Actor *)jarg1;
22041   arg2 = (float)jarg2;
22042   arg3 = (float)jarg3;
22043   {
22044     try {
22045       (arg1)->SetProperty( Actor::Property::SIZE, Dali::Vector2(arg2,arg3) );
22046     } CALL_CATCH_EXCEPTION();
22047   }
22048
22049 }
22050
22051
22052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
22053   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22054   float arg2 ;
22055   float arg3 ;
22056   float arg4 ;
22057
22058   arg1 = (Dali::Actor *)jarg1;
22059   arg2 = (float)jarg2;
22060   arg3 = (float)jarg3;
22061   arg4 = (float)jarg4;
22062   {
22063     try {
22064       (arg1)->SetProperty( Actor::Property::SIZE, Dali::Vector3(arg2,arg3,arg4) );
22065     } CALL_CATCH_EXCEPTION();
22066   }
22067
22068 }
22069
22070
22071 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_2(void * jarg1, void * jarg2) {
22072   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22073   Dali::Vector2 *arg2 = 0 ;
22074
22075   arg1 = (Dali::Actor *)jarg1;
22076   arg2 = (Dali::Vector2 *)jarg2;
22077   if (!arg2) {
22078     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
22079     return ;
22080   }
22081   {
22082     try {
22083       (arg1)->SetProperty( Actor::Property::SIZE, (Dali::Vector2 const &)*arg2);
22084     } CALL_CATCH_EXCEPTION();
22085   }
22086
22087 }
22088
22089
22090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_3(void * jarg1, void * jarg2) {
22091   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22092   Dali::Vector3 *arg2 = 0 ;
22093
22094   arg1 = (Dali::Actor *)jarg1;
22095   arg2 = (Dali::Vector3 *)jarg2;
22096   if (!arg2) {
22097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
22098     return ;
22099   }
22100   {
22101     try {
22102       (arg1)->SetProperty( Actor::Property::SIZE, (Dali::Vector3 const &)*arg2);
22103     } CALL_CATCH_EXCEPTION();
22104   }
22105
22106 }
22107
22108
22109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetTargetSize(void * jarg1) {
22110   void * jresult ;
22111   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22112   Dali::Vector3 result;
22113
22114   arg1 = (Dali::Actor *)jarg1;
22115   {
22116     try {
22117       result = ((Dali::Actor const *)arg1)->GetTargetSize();
22118     } CALL_CATCH_EXCEPTION(0);
22119   }
22120
22121   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
22122   return jresult;
22123 }
22124
22125
22126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentSize(void * jarg1) {
22127   void * jresult ;
22128   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22129   Dali::Vector3 result;
22130
22131   arg1 = (Dali::Actor *)jarg1;
22132   {
22133     try {
22134       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::SIZE );
22135     } CALL_CATCH_EXCEPTION(0);
22136   }
22137
22138   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
22139   return jresult;
22140 }
22141
22142
22143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetNaturalSize(void * jarg1) {
22144   void * jresult ;
22145   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22146   Dali::Vector3 result;
22147
22148   arg1 = (Dali::Actor *)jarg1;
22149   {
22150     try {
22151       result = ((Dali::Actor const *)arg1)->GetNaturalSize();
22152     } CALL_CATCH_EXCEPTION(0);
22153   }
22154
22155   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
22156   return jresult;
22157 }
22158
22159
22160 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_0(void * jarg1, float jarg2, float jarg3) {
22161   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22162   float arg2 ;
22163   float arg3 ;
22164
22165   arg1 = (Dali::Actor *)jarg1;
22166   arg2 = (float)jarg2;
22167   arg3 = (float)jarg3;
22168   {
22169     try {
22170       (arg1)->SetProperty( Actor::Property::POSITION, Dali::Vector2( arg2, arg3 ) );
22171     } CALL_CATCH_EXCEPTION();
22172   }
22173
22174 }
22175
22176
22177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
22178   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22179   float arg2 ;
22180   float arg3 ;
22181   float arg4 ;
22182
22183   arg1 = (Dali::Actor *)jarg1;
22184   arg2 = (float)jarg2;
22185   arg3 = (float)jarg3;
22186   arg4 = (float)jarg4;
22187   {
22188     try {
22189       (arg1)->SetProperty( Actor::Property::POSITION, Dali::Vector3( arg2, arg3, arg4 ) );
22190     } CALL_CATCH_EXCEPTION();
22191   }
22192
22193 }
22194
22195
22196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_2(void * jarg1, void * jarg2) {
22197   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22198   Dali::Vector3 *arg2 = 0 ;
22199
22200   arg1 = (Dali::Actor *)jarg1;
22201   arg2 = (Dali::Vector3 *)jarg2;
22202   if (!arg2) {
22203     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
22204     return ;
22205   }
22206   {
22207     try {
22208       (arg1)->SetProperty( Actor::Property::POSITION, (Dali::Vector3 const &)*arg2 );
22209     } CALL_CATCH_EXCEPTION();
22210   }
22211
22212 }
22213
22214
22215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetX(void * jarg1, float jarg2) {
22216   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22217   float arg2 ;
22218
22219   arg1 = (Dali::Actor *)jarg1;
22220   arg2 = (float)jarg2;
22221   {
22222     try {
22223       (arg1)->SetProperty( Actor::Property::POSITION_X, (arg2) );
22224     } CALL_CATCH_EXCEPTION();
22225   }
22226
22227 }
22228
22229
22230 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetY(void * jarg1, float jarg2) {
22231   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22232   float arg2 ;
22233
22234   arg1 = (Dali::Actor *)jarg1;
22235   arg2 = (float)jarg2;
22236   {
22237     try {
22238       (arg1)->SetProperty( Actor::Property::POSITION_Y, arg2 );
22239     } CALL_CATCH_EXCEPTION();
22240   }
22241
22242 }
22243
22244
22245 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetZ(void * jarg1, float jarg2) {
22246   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22247   float arg2 ;
22248
22249   arg1 = (Dali::Actor *)jarg1;
22250   arg2 = (float)jarg2;
22251   {
22252     try {
22253       (arg1)->SetProperty( Actor::Property::POSITION_Z, arg2 );
22254     } CALL_CATCH_EXCEPTION();
22255   }
22256
22257 }
22258
22259
22260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_TranslateBy(void * jarg1, void * jarg2) {
22261   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22262   Dali::Vector3 *arg2 = 0 ;
22263
22264   arg1 = (Dali::Actor *)jarg1;
22265   arg2 = (Dali::Vector3 *)jarg2;
22266   if (!arg2) {
22267     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
22268     return ;
22269   }
22270   {
22271     try {
22272       (arg1)->TranslateBy((Dali::Vector3 const &)*arg2);
22273     } CALL_CATCH_EXCEPTION();
22274   }
22275
22276 }
22277
22278
22279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentPosition(void * jarg1) {
22280   void * jresult ;
22281   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22282   Dali::Vector3 result;
22283
22284   arg1 = (Dali::Actor *)jarg1;
22285   {
22286     try {
22287       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::POSITION );
22288     } CALL_CATCH_EXCEPTION(0);
22289   }
22290
22291   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
22292   return jresult;
22293 }
22294
22295
22296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldPosition(void * jarg1) {
22297   void * jresult ;
22298   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22299   Dali::Vector3 result;
22300
22301   arg1 = (Dali::Actor *)jarg1;
22302   {
22303     try {
22304       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::WORLD_POSITION );
22305     } CALL_CATCH_EXCEPTION(0);
22306   }
22307
22308   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
22309   return jresult;
22310 }
22311
22312
22313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritPosition(void * jarg1, unsigned int jarg2) {
22314   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22315   bool arg2 ;
22316
22317   arg1 = (Dali::Actor *)jarg1;
22318   arg2 = jarg2 ? true : false;
22319   {
22320     try {
22321       (arg1)->SetProperty(Dali::Actor::Property::INHERIT_POSITION, arg2);
22322     } CALL_CATCH_EXCEPTION();
22323   }
22324
22325 }
22326
22327
22328 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsPositionInherited(void * jarg1) {
22329   unsigned int jresult ;
22330   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22331   bool result;
22332
22333   arg1 = (Dali::Actor *)jarg1;
22334   {
22335     try {
22336       result = (bool)((Dali::Actor const *)arg1)->GetProperty<bool>(Dali::Actor::Property::INHERIT_POSITION);
22337     } CALL_CATCH_EXCEPTION(0);
22338   }
22339
22340   jresult = result;
22341   return jresult;
22342 }
22343
22344
22345 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
22346   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22347   Dali::Degree *arg2 = 0 ;
22348   Dali::Vector3 *arg3 = 0 ;
22349
22350   arg1 = (Dali::Actor *)jarg1;
22351   arg2 = (Dali::Degree *)jarg2;
22352   if (!arg2) {
22353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
22354     return ;
22355   }
22356   arg3 = (Dali::Vector3 *)jarg3;
22357   if (!arg3) {
22358     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
22359     return ;
22360   }
22361   {
22362     try {
22363       (arg1)->SetProperty( Actor::Property::ORIENTATION, Quaternion( (Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3 ) );
22364     } CALL_CATCH_EXCEPTION();
22365   }
22366
22367 }
22368
22369
22370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
22371   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22372   Dali::Radian *arg2 = 0 ;
22373   Dali::Vector3 *arg3 = 0 ;
22374
22375   arg1 = (Dali::Actor *)jarg1;
22376   arg2 = (Dali::Radian *)jarg2;
22377   if (!arg2) {
22378     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
22379     return ;
22380   }
22381   arg3 = (Dali::Vector3 *)jarg3;
22382   if (!arg3) {
22383     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
22384     return ;
22385   }
22386   {
22387     try {
22388       (arg1)->SetProperty( Actor::Property::ORIENTATION, Quaternion( (Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3 ) );
22389     } CALL_CATCH_EXCEPTION();
22390   }
22391
22392 }
22393
22394
22395 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_2(void * jarg1, void * jarg2) {
22396   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22397   Dali::Quaternion *arg2 = 0 ;
22398
22399   arg1 = (Dali::Actor *)jarg1;
22400   arg2 = (Dali::Quaternion *)jarg2;
22401   if (!arg2) {
22402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
22403     return ;
22404   }
22405   {
22406     try {
22407       (arg1)->SetProperty( Actor::Property::ORIENTATION, (Dali::Quaternion const &)*arg2 );
22408     } CALL_CATCH_EXCEPTION();
22409   }
22410
22411 }
22412
22413
22414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
22415   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22416   Dali::Degree *arg2 = 0 ;
22417   Dali::Vector3 *arg3 = 0 ;
22418
22419   arg1 = (Dali::Actor *)jarg1;
22420   arg2 = (Dali::Degree *)jarg2;
22421   if (!arg2) {
22422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
22423     return ;
22424   }
22425   arg3 = (Dali::Vector3 *)jarg3;
22426   if (!arg3) {
22427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
22428     return ;
22429   }
22430   {
22431     try {
22432       (arg1)->RotateBy((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
22433     } CALL_CATCH_EXCEPTION();
22434   }
22435
22436 }
22437
22438
22439 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
22440   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22441   Dali::Radian *arg2 = 0 ;
22442   Dali::Vector3 *arg3 = 0 ;
22443
22444   arg1 = (Dali::Actor *)jarg1;
22445   arg2 = (Dali::Radian *)jarg2;
22446   if (!arg2) {
22447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
22448     return ;
22449   }
22450   arg3 = (Dali::Vector3 *)jarg3;
22451   if (!arg3) {
22452     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
22453     return ;
22454   }
22455   {
22456     try {
22457       (arg1)->RotateBy((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
22458     } CALL_CATCH_EXCEPTION();
22459   }
22460
22461 }
22462
22463
22464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_2(void * jarg1, void * jarg2) {
22465   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22466   Dali::Quaternion *arg2 = 0 ;
22467
22468   arg1 = (Dali::Actor *)jarg1;
22469   arg2 = (Dali::Quaternion *)jarg2;
22470   if (!arg2) {
22471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
22472     return ;
22473   }
22474   {
22475     try {
22476       (arg1)->RotateBy((Dali::Quaternion const &)*arg2);
22477     } CALL_CATCH_EXCEPTION();
22478   }
22479
22480 }
22481
22482
22483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOrientation(void * jarg1) {
22484   void * jresult ;
22485   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22486   Dali::Quaternion result;
22487
22488   arg1 = (Dali::Actor *)jarg1;
22489   {
22490     try {
22491       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION );
22492     } CALL_CATCH_EXCEPTION(0);
22493   }
22494
22495   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
22496   return jresult;
22497 }
22498
22499
22500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritOrientation(void * jarg1, unsigned int jarg2) {
22501   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22502   bool arg2 ;
22503
22504   arg1 = (Dali::Actor *)jarg1;
22505   arg2 = jarg2 ? true : false;
22506   {
22507     try {
22508       (arg1)->SetProperty( Actor::Property::INHERIT_ORIENTATION,arg2);
22509     } CALL_CATCH_EXCEPTION();
22510   }
22511
22512 }
22513
22514
22515 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsOrientationInherited(void * jarg1) {
22516   unsigned int jresult ;
22517   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22518   bool result;
22519
22520   arg1 = (Dali::Actor *)jarg1;
22521   {
22522     try {
22523       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::INHERIT_ORIENTATION );
22524     } CALL_CATCH_EXCEPTION(0);
22525   }
22526
22527   jresult = result;
22528   return jresult;
22529 }
22530
22531
22532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldOrientation(void * jarg1) {
22533   void * jresult ;
22534   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22535   Dali::Quaternion result;
22536
22537   arg1 = (Dali::Actor *)jarg1;
22538   {
22539     try {
22540       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Quaternion >( Actor::Property::WORLD_ORIENTATION );
22541     } CALL_CATCH_EXCEPTION(0);
22542   }
22543
22544   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
22545   return jresult;
22546 }
22547
22548
22549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_0(void * jarg1, float jarg2) {
22550   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22551   float arg2 ;
22552
22553   arg1 = (Dali::Actor *)jarg1;
22554   arg2 = (float)jarg2;
22555   {
22556     try {
22557       (arg1)->SetProperty( Actor::Property::SCALE, arg2);
22558     } CALL_CATCH_EXCEPTION();
22559   }
22560
22561 }
22562
22563
22564 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
22565   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22566   float arg2 ;
22567   float arg3 ;
22568   float arg4 ;
22569
22570   arg1 = (Dali::Actor *)jarg1;
22571   arg2 = (float)jarg2;
22572   arg3 = (float)jarg3;
22573   arg4 = (float)jarg4;
22574   {
22575     try {
22576       (arg1)->SetProperty( Actor::Property::SCALE, Vector3( arg2, arg3, arg4 ) );
22577     } CALL_CATCH_EXCEPTION();
22578   }
22579
22580 }
22581
22582
22583 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_2(void * jarg1, void * jarg2) {
22584   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22585   Dali::Vector3 *arg2 = 0 ;
22586
22587   arg1 = (Dali::Actor *)jarg1;
22588   arg2 = (Dali::Vector3 *)jarg2;
22589   if (!arg2) {
22590     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
22591     return ;
22592   }
22593   {
22594     try {
22595       (arg1)->SetProperty( Actor::Property::SCALE, (Dali::Vector3 const &)*arg2 );
22596     } CALL_CATCH_EXCEPTION();
22597   }
22598
22599 }
22600
22601
22602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_ScaleBy(void * jarg1, void * jarg2) {
22603   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22604   Dali::Vector3 *arg2 = 0 ;
22605
22606   arg1 = (Dali::Actor *)jarg1;
22607   arg2 = (Dali::Vector3 *)jarg2;
22608   if (!arg2) {
22609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
22610     return ;
22611   }
22612   {
22613     try {
22614       (arg1)->ScaleBy((Dali::Vector3 const &)*arg2);
22615     } CALL_CATCH_EXCEPTION();
22616   }
22617
22618 }
22619
22620
22621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentScale(void * jarg1) {
22622   void * jresult ;
22623   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22624   Dali::Vector3 result;
22625
22626   arg1 = (Dali::Actor *)jarg1;
22627   {
22628     try {
22629       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::SCALE );
22630     } CALL_CATCH_EXCEPTION(0);
22631   }
22632
22633   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
22634   return jresult;
22635 }
22636
22637
22638 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldScale(void * jarg1) {
22639   void * jresult ;
22640   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22641   Dali::Vector3 result;
22642
22643   arg1 = (Dali::Actor *)jarg1;
22644   {
22645     try {
22646       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::WORLD_SCALE );
22647     } CALL_CATCH_EXCEPTION(0);
22648   }
22649
22650   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
22651   return jresult;
22652 }
22653
22654
22655 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritScale(void * jarg1, unsigned int jarg2) {
22656   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22657   bool arg2 ;
22658
22659   arg1 = (Dali::Actor *)jarg1;
22660   arg2 = jarg2 ? true : false;
22661   {
22662     try {
22663       (arg1)->SetProperty( Actor::Property::INHERIT_SCALE,arg2);
22664     } CALL_CATCH_EXCEPTION();
22665   }
22666
22667 }
22668
22669
22670 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsScaleInherited(void * jarg1) {
22671   unsigned int jresult ;
22672   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22673   bool result;
22674
22675   arg1 = (Dali::Actor *)jarg1;
22676   {
22677     try {
22678       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::INHERIT_SCALE );
22679     } CALL_CATCH_EXCEPTION(0);
22680   }
22681
22682   jresult = result;
22683   return jresult;
22684 }
22685
22686
22687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldMatrix(void * jarg1) {
22688   void * jresult ;
22689   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22690   Dali::Matrix result;
22691
22692   arg1 = (Dali::Actor *)jarg1;
22693   {
22694     try {
22695       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Matrix >( Actor::Property::WORLD_MATRIX );
22696     } CALL_CATCH_EXCEPTION(0);
22697   }
22698
22699   jresult = new Dali::Matrix((const Dali::Matrix &)result);
22700   return jresult;
22701 }
22702
22703
22704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetVisible(void * jarg1, unsigned int jarg2) {
22705   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22706   bool arg2 ;
22707
22708   arg1 = (Dali::Actor *)jarg1;
22709   arg2 = jarg2 ? true : false;
22710   {
22711     try {
22712       (arg1)->SetProperty( Actor::Property::VISIBLE,arg2);
22713     } CALL_CATCH_EXCEPTION();
22714   }
22715
22716 }
22717
22718
22719 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsVisible(void * jarg1) {
22720   unsigned int jresult ;
22721   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22722   bool result;
22723
22724   arg1 = (Dali::Actor *)jarg1;
22725   {
22726     try {
22727       result = (bool)((Dali::Actor const *)arg1)->GetCurrentProperty< bool >( Actor::Property::VISIBLE );
22728     } CALL_CATCH_EXCEPTION(0);
22729   }
22730
22731   jresult = result;
22732   return jresult;
22733 }
22734
22735
22736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOpacity(void * jarg1, float jarg2) {
22737   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22738   float arg2 ;
22739
22740   arg1 = (Dali::Actor *)jarg1;
22741   arg2 = (float)jarg2;
22742   {
22743     try {
22744       (arg1)->SetProperty( Actor::Property::OPACITY,arg2);
22745     } CALL_CATCH_EXCEPTION();
22746   }
22747
22748 }
22749
22750
22751 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOpacity(void * jarg1) {
22752   float jresult ;
22753   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22754   float result;
22755
22756   arg1 = (Dali::Actor *)jarg1;
22757   {
22758     try {
22759       result = (float)((Dali::Actor const *)arg1)->GetCurrentProperty< float >( Actor::Property::OPACITY );
22760     } CALL_CATCH_EXCEPTION(0);
22761   }
22762
22763   jresult = result;
22764   return jresult;
22765 }
22766
22767
22768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColor(void * jarg1, void * jarg2) {
22769   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22770   Dali::Vector4 *arg2 = 0 ;
22771
22772   arg1 = (Dali::Actor *)jarg1;
22773   arg2 = (Dali::Vector4 *)jarg2;
22774   if (!arg2) {
22775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
22776     return ;
22777   }
22778   {
22779     try {
22780       (arg1)->SetProperty( Actor::Property::COLOR,(Dali::Vector4 const &)*arg2);
22781     } CALL_CATCH_EXCEPTION();
22782   }
22783
22784 }
22785
22786
22787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentColor(void * jarg1) {
22788   void * jresult ;
22789   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22790   Dali::Vector4 result;
22791
22792   arg1 = (Dali::Actor *)jarg1;
22793   {
22794     try {
22795       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector4 >( Actor::Property::COLOR );
22796     } CALL_CATCH_EXCEPTION(0);
22797   }
22798
22799   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
22800   return jresult;
22801 }
22802
22803
22804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColorMode(void * jarg1, int jarg2) {
22805   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22806   Dali::ColorMode arg2 ;
22807
22808   arg1 = (Dali::Actor *)jarg1;
22809   arg2 = (Dali::ColorMode)jarg2;
22810   {
22811     try {
22812       (arg1)->SetProperty( Actor::Property::COLOR_MODE,arg2);
22813     } CALL_CATCH_EXCEPTION();
22814   }
22815
22816 }
22817
22818
22819 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetColorMode(void * jarg1) {
22820   int jresult ;
22821   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22822   Dali::ColorMode result;
22823
22824   arg1 = (Dali::Actor *)jarg1;
22825   {
22826     try {
22827       result = (Dali::ColorMode)((Dali::Actor const *)arg1)->GetProperty< ColorMode >( Actor::Property::COLOR_MODE );
22828     } CALL_CATCH_EXCEPTION(0);
22829   }
22830
22831   jresult = (int)result;
22832   return jresult;
22833 }
22834
22835
22836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldColor(void * jarg1) {
22837   void * jresult ;
22838   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22839   Dali::Vector4 result;
22840
22841   arg1 = (Dali::Actor *)jarg1;
22842   {
22843     try {
22844       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector4 >( Actor::Property::WORLD_COLOR );
22845     } CALL_CATCH_EXCEPTION(0);
22846   }
22847
22848   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
22849   return jresult;
22850 }
22851
22852
22853 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetDrawMode(void * jarg1, int jarg2) {
22854   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22855   Dali::DrawMode::Type arg2 ;
22856
22857   arg1 = (Dali::Actor *)jarg1;
22858   arg2 = (Dali::DrawMode::Type)jarg2;
22859   {
22860     try {
22861       (arg1)->SetProperty( Actor::Property::DRAW_MODE,arg2);
22862     } CALL_CATCH_EXCEPTION();
22863   }
22864
22865 }
22866
22867
22868 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetDrawMode(void * jarg1) {
22869   int jresult ;
22870   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22871   Dali::DrawMode::Type result;
22872
22873   arg1 = (Dali::Actor *)jarg1;
22874   {
22875     try {
22876       result = (Dali::DrawMode::Type)((Dali::Actor const *)arg1)->GetProperty< DrawMode::Type >( Actor::Property::DRAW_MODE );
22877     } CALL_CATCH_EXCEPTION(0);
22878   }
22879
22880   jresult = (int)result;
22881   return jresult;
22882 }
22883
22884
22885 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSensitive(void * jarg1, unsigned int jarg2) {
22886   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22887   bool arg2 ;
22888
22889   arg1 = (Dali::Actor *)jarg1;
22890   arg2 = jarg2 ? true : false;
22891   {
22892     try {
22893       (arg1)->SetProperty( Actor::Property::SENSITIVE,arg2);
22894     } CALL_CATCH_EXCEPTION();
22895   }
22896
22897 }
22898
22899
22900 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsSensitive(void * jarg1) {
22901   unsigned int jresult ;
22902   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22903   bool result;
22904
22905   arg1 = (Dali::Actor *)jarg1;
22906   {
22907     try {
22908       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::SENSITIVE );
22909     } CALL_CATCH_EXCEPTION(0);
22910   }
22911
22912   jresult = result;
22913   return jresult;
22914 }
22915
22916
22917 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_ScreenToLocal(void * jarg1, float * jarg2, float * jarg3, float jarg4, float jarg5) {
22918   unsigned int jresult ;
22919   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22920   float *arg2 = 0 ;
22921   float *arg3 = 0 ;
22922   float arg4 ;
22923   float arg5 ;
22924   bool result;
22925
22926   arg1 = (Dali::Actor *)jarg1;
22927   arg2 = (float *)jarg2;
22928   arg3 = (float *)jarg3;
22929   arg4 = (float)jarg4;
22930   arg5 = (float)jarg5;
22931   {
22932     try {
22933       result = (bool)((Dali::Actor const *)arg1)->ScreenToLocal(*arg2,*arg3,arg4,arg5);
22934     } CALL_CATCH_EXCEPTION(0);
22935   }
22936
22937   jresult = result;
22938   return jresult;
22939 }
22940
22941
22942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetLeaveRequired(void * jarg1, unsigned int jarg2) {
22943   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22944   bool arg2 ;
22945
22946   arg1 = (Dali::Actor *)jarg1;
22947   arg2 = jarg2 ? true : false;
22948   {
22949     try {
22950       (arg1)->SetProperty( Actor::Property::LEAVE_REQUIRED,arg2);
22951     } CALL_CATCH_EXCEPTION();
22952   }
22953
22954 }
22955
22956
22957 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetLeaveRequired(void * jarg1) {
22958   unsigned int jresult ;
22959   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22960   bool result;
22961
22962   arg1 = (Dali::Actor *)jarg1;
22963   {
22964     try {
22965       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::LEAVE_REQUIRED );
22966     } CALL_CATCH_EXCEPTION(0);
22967   }
22968
22969   jresult = result;
22970   return jresult;
22971 }
22972
22973
22974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusable(void * jarg1, unsigned int jarg2) {
22975   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22976   bool arg2 ;
22977
22978   arg1 = (Dali::Actor *)jarg1;
22979   arg2 = jarg2 ? true : false;
22980   {
22981     try {
22982       (arg1)->SetProperty( Actor::Property::KEYBOARD_FOCUSABLE, arg2 );
22983     } CALL_CATCH_EXCEPTION();
22984   }
22985
22986 }
22987
22988
22989 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsKeyboardFocusable(void * jarg1) {
22990   unsigned int jresult ;
22991   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22992   bool result;
22993
22994   arg1 = (Dali::Actor *)jarg1;
22995   {
22996     try {
22997       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::KEYBOARD_FOCUSABLE );
22998     } CALL_CATCH_EXCEPTION(0);
22999   }
23000
23001   jresult = result;
23002   return jresult;
23003 }
23004
23005
23006 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetResizePolicy(void * jarg1, int jarg2, int jarg3) {
23007   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23008   Dali::ResizePolicy::Type arg2 ;
23009   Dali::Dimension::Type arg3 ;
23010
23011   arg1 = (Dali::Actor *)jarg1;
23012   arg2 = (Dali::ResizePolicy::Type)jarg2;
23013   arg3 = (Dali::Dimension::Type)jarg3;
23014   {
23015     try {
23016       (arg1)->SetResizePolicy(arg2,arg3);
23017     } CALL_CATCH_EXCEPTION();
23018   }
23019
23020 }
23021
23022
23023 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetResizePolicy(void * jarg1, int jarg2) {
23024   int jresult ;
23025   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23026   Dali::Dimension::Type arg2 ;
23027   Dali::ResizePolicy::Type result;
23028
23029   arg1 = (Dali::Actor *)jarg1;
23030   arg2 = (Dali::Dimension::Type)jarg2;
23031   {
23032     try {
23033       result = (Dali::ResizePolicy::Type)((Dali::Actor const *)arg1)->GetResizePolicy(arg2);
23034     } CALL_CATCH_EXCEPTION(0);
23035   }
23036
23037   jresult = (int)result;
23038   return jresult;
23039 }
23040
23041
23042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeScalePolicy(void * jarg1, int jarg2) {
23043   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23044   Dali::SizeScalePolicy::Type arg2 ;
23045
23046   arg1 = (Dali::Actor *)jarg1;
23047   arg2 = (Dali::SizeScalePolicy::Type)jarg2;
23048   {
23049     try {
23050       (arg1)->SetProperty( Actor::Property::SIZE_SCALE_POLICY,arg2);
23051     } CALL_CATCH_EXCEPTION();
23052   }
23053
23054 }
23055
23056
23057 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetSizeScalePolicy(void * jarg1) {
23058   int jresult ;
23059   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23060   Dali::SizeScalePolicy::Type result;
23061
23062   arg1 = (Dali::Actor *)jarg1;
23063   {
23064     try {
23065       result = (Dali::SizeScalePolicy::Type)((Dali::Actor const *)arg1)->GetProperty< SizeScalePolicy::Type >( Actor::Property::SIZE_SCALE_POLICY );
23066     } CALL_CATCH_EXCEPTION(0);
23067   }
23068
23069   jresult = (int)result;
23070   return jresult;
23071 }
23072
23073
23074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeModeFactor(void * jarg1, void * jarg2) {
23075   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23076   Dali::Vector3 *arg2 = 0 ;
23077
23078   arg1 = (Dali::Actor *)jarg1;
23079   arg2 = (Dali::Vector3 *)jarg2;
23080   if (!arg2) {
23081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
23082     return ;
23083   }
23084   {
23085     try {
23086       (arg1)->SetProperty( Actor::Property::SIZE_MODE_FACTOR, (Dali::Vector3 const &)*arg2);
23087     } CALL_CATCH_EXCEPTION();
23088   }
23089
23090 }
23091
23092
23093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetSizeModeFactor(void * jarg1) {
23094   void * jresult ;
23095   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23096   Dali::Vector3 result;
23097
23098   arg1 = (Dali::Actor *)jarg1;
23099   {
23100     try {
23101       result = ((Dali::Actor const *)arg1)->GetProperty< Vector3 >( Actor::Property::SIZE_MODE_FACTOR );
23102     } CALL_CATCH_EXCEPTION(0);
23103   }
23104
23105   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
23106   return jresult;
23107 }
23108
23109
23110 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetHeightForWidth(void * jarg1, float jarg2) {
23111   float jresult ;
23112   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23113   float arg2 ;
23114   float result;
23115
23116   arg1 = (Dali::Actor *)jarg1;
23117   arg2 = (float)jarg2;
23118   {
23119     try {
23120       result = (float)(arg1)->GetHeightForWidth(arg2);
23121     } CALL_CATCH_EXCEPTION(0);
23122   }
23123
23124   jresult = result;
23125   return jresult;
23126 }
23127
23128
23129 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetWidthForHeight(void * jarg1, float jarg2) {
23130   float jresult ;
23131   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23132   float arg2 ;
23133   float result;
23134
23135   arg1 = (Dali::Actor *)jarg1;
23136   arg2 = (float)jarg2;
23137   {
23138     try {
23139       result = (float)(arg1)->GetWidthForHeight(arg2);
23140     } CALL_CATCH_EXCEPTION(0);
23141   }
23142
23143   jresult = result;
23144   return jresult;
23145 }
23146
23147
23148 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetRelayoutSize(void * jarg1, int jarg2) {
23149   float jresult ;
23150   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23151   Dali::Dimension::Type arg2 ;
23152   float result;
23153
23154   arg1 = (Dali::Actor *)jarg1;
23155   arg2 = (Dali::Dimension::Type)jarg2;
23156   {
23157     try {
23158       result = (float)((Dali::Actor const *)arg1)->GetRelayoutSize(arg2);
23159     } CALL_CATCH_EXCEPTION(0);
23160   }
23161
23162   jresult = result;
23163   return jresult;
23164 }
23165
23166
23167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPadding(void * jarg1, void * jarg2) {
23168   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23169   Dali::Padding *arg2 = 0 ;
23170
23171   arg1 = (Dali::Actor *)jarg1;
23172   arg2 = (Dali::Padding *)jarg2;
23173   if (!arg2) {
23174     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding const & type is null", 0);
23175     return ;
23176   }
23177   {
23178     try {
23179       (arg1)->SetProperty( Actor::Property::PADDING, (Dali::Padding const &)*arg2);
23180     } CALL_CATCH_EXCEPTION();
23181   }
23182
23183 }
23184
23185
23186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_GetPadding(void * jarg1, void * jarg2) {
23187   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23188   Dali::Padding *arg2 = 0 ;
23189
23190   arg1 = (Dali::Actor *)jarg1;
23191   arg2 = (Dali::Padding *)jarg2;
23192   if (!arg2) {
23193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding & type is null", 0);
23194     return ;
23195   }
23196   {
23197     try {
23198       *arg2 = ((Dali::Actor const *)arg1)->GetProperty<Vector4>( Actor::Property::PADDING );
23199     } CALL_CATCH_EXCEPTION();
23200   }
23201
23202 }
23203
23204
23205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMinimumSize(void * jarg1, void * jarg2) {
23206   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23207   Dali::Vector2 *arg2 = 0 ;
23208
23209   arg1 = (Dali::Actor *)jarg1;
23210   arg2 = (Dali::Vector2 *)jarg2;
23211   if (!arg2) {
23212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
23213     return ;
23214   }
23215   {
23216     try {
23217       (arg1)->SetProperty( Actor::Property::MINIMUM_SIZE,(Dali::Vector2 const &)*arg2);
23218     } CALL_CATCH_EXCEPTION();
23219   }
23220
23221 }
23222
23223
23224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMinimumSize(void * jarg1) {
23225   void * jresult ;
23226   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23227   Dali::Vector2 result;
23228
23229   arg1 = (Dali::Actor *)jarg1;
23230   {
23231     try {
23232       result = (arg1)->GetProperty< Vector2 >( Actor::Property::MINIMUM_SIZE );
23233     } CALL_CATCH_EXCEPTION(0);
23234   }
23235
23236   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
23237   return jresult;
23238 }
23239
23240
23241 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMaximumSize(void * jarg1, void * jarg2) {
23242   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23243   Dali::Vector2 *arg2 = 0 ;
23244
23245   arg1 = (Dali::Actor *)jarg1;
23246   arg2 = (Dali::Vector2 *)jarg2;
23247   if (!arg2) {
23248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
23249     return ;
23250   }
23251   {
23252     try {
23253       (arg1)->SetProperty( Actor::Property::MAXIMUM_SIZE,(Dali::Vector2 const &)*arg2);
23254     } CALL_CATCH_EXCEPTION();
23255   }
23256
23257 }
23258
23259
23260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMaximumSize(void * jarg1) {
23261   void * jresult ;
23262   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23263   Dali::Vector2 result;
23264
23265   arg1 = (Dali::Actor *)jarg1;
23266   {
23267     try {
23268       result = (arg1)->GetProperty< Vector2 >( Actor::Property::MAXIMUM_SIZE );
23269     } CALL_CATCH_EXCEPTION(0);
23270   }
23271
23272   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
23273   return jresult;
23274 }
23275
23276
23277 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetHierarchyDepth(void * jarg1) {
23278   int jresult ;
23279   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23280   int result;
23281
23282   arg1 = (Dali::Actor *)jarg1;
23283   {
23284     try {
23285       result = (int)(arg1)->GetProperty< int >( Actor::Property::HIERARCHY_DEPTH );
23286       Dali::Actor parent = ((Dali::Actor const *)arg1)->GetParent();
23287     } CALL_CATCH_EXCEPTION(0);
23288   }
23289
23290   jresult = result;
23291   return jresult;
23292 }
23293
23294
23295 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_AddRenderer(void * jarg1, void * jarg2) {
23296   unsigned int jresult ;
23297   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23298   Dali::Renderer *arg2 = 0 ;
23299   unsigned int result;
23300
23301   arg1 = (Dali::Actor *)jarg1;
23302   arg2 = (Dali::Renderer *)jarg2;
23303   if (!arg2) {
23304     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
23305     return 0;
23306   }
23307   {
23308     try {
23309       result = (unsigned int)(arg1)->AddRenderer(*arg2);
23310     } CALL_CATCH_EXCEPTION(0);
23311   }
23312
23313   jresult = result;
23314   return jresult;
23315 }
23316
23317
23318 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetRendererCount(void * jarg1) {
23319   unsigned int jresult ;
23320   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23321   unsigned int result;
23322
23323   arg1 = (Dali::Actor *)jarg1;
23324   {
23325     try {
23326       result = (unsigned int)((Dali::Actor const *)arg1)->GetRendererCount();
23327     } CALL_CATCH_EXCEPTION(0);
23328   }
23329
23330   jresult = result;
23331   return jresult;
23332 }
23333
23334
23335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetRendererAt(void * jarg1, unsigned int jarg2) {
23336   void * jresult ;
23337   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23338   unsigned int arg2 ;
23339   Dali::Renderer result;
23340
23341   arg1 = (Dali::Actor *)jarg1;
23342   arg2 = (unsigned int)jarg2;
23343   {
23344     try {
23345       result = (arg1)->GetRendererAt(arg2);
23346     } CALL_CATCH_EXCEPTION(0);
23347   }
23348
23349   jresult = new Dali::Renderer((const Dali::Renderer &)result);
23350   return jresult;
23351 }
23352
23353
23354 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_0(void * jarg1, void * jarg2) {
23355   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23356   Dali::Renderer *arg2 = 0 ;
23357
23358   arg1 = (Dali::Actor *)jarg1;
23359   arg2 = (Dali::Renderer *)jarg2;
23360   if (!arg2) {
23361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
23362     return ;
23363   }
23364   {
23365     try {
23366       (arg1)->RemoveRenderer(*arg2);
23367     } CALL_CATCH_EXCEPTION();
23368   }
23369
23370 }
23371
23372
23373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_1(void * jarg1, unsigned int jarg2) {
23374   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23375   unsigned int arg2 ;
23376
23377   arg1 = (Dali::Actor *)jarg1;
23378   arg2 = (unsigned int)jarg2;
23379   {
23380     try {
23381       (arg1)->RemoveRenderer(arg2);
23382     } CALL_CATCH_EXCEPTION();
23383   }
23384
23385 }
23386
23387
23388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchSignal(void * jarg1) {
23389   void * jresult ;
23390   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23391   Dali::Actor::TouchEventSignalType *result = 0 ;
23392
23393   arg1 = (Dali::Actor *)jarg1;
23394   {
23395     try {
23396       result = (Dali::Actor::TouchEventSignalType *) &(arg1)->TouchSignal();
23397     } CALL_CATCH_EXCEPTION(0);
23398   }
23399
23400   jresult = (void *)result;
23401   return jresult;
23402 }
23403
23404
23405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_HoveredSignal(void * jarg1) {
23406   void * jresult ;
23407   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23408   Dali::Actor::HoverSignalType *result = 0 ;
23409
23410   arg1 = (Dali::Actor *)jarg1;
23411   {
23412     try {
23413       result = (Dali::Actor::HoverSignalType *) &(arg1)->HoveredSignal();
23414     } CALL_CATCH_EXCEPTION(0);
23415   }
23416
23417   jresult = (void *)result;
23418   return jresult;
23419 }
23420
23421
23422 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_WheelEventSignal(void * jarg1) {
23423   void * jresult ;
23424   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23425   Dali::Actor::WheelEventSignalType *result = 0 ;
23426
23427   arg1 = (Dali::Actor *)jarg1;
23428   {
23429     try {
23430       result = (Dali::Actor::WheelEventSignalType *) &(arg1)->WheelEventSignal();
23431     } CALL_CATCH_EXCEPTION(0);
23432   }
23433
23434   jresult = (void *)result;
23435   return jresult;
23436 }
23437
23438
23439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnSceneSignal(void * jarg1) {
23440   void * jresult ;
23441   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23442   Dali::Actor::OnSceneSignalType *result = 0 ;
23443
23444   arg1 = (Dali::Actor *)jarg1;
23445   {
23446     try {
23447       result = (Dali::Actor::OnSceneSignalType *) &(arg1)->OnSceneSignal();
23448     } CALL_CATCH_EXCEPTION(0);
23449   }
23450
23451   jresult = (void *)result;
23452   return jresult;
23453 }
23454
23455
23456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OffSceneSignal(void * jarg1) {
23457   void * jresult ;
23458   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23459   Dali::Actor::OffSceneSignalType *result = 0 ;
23460
23461   arg1 = (Dali::Actor *)jarg1;
23462   {
23463     try {
23464       result = (Dali::Actor::OffSceneSignalType *) &(arg1)->OffSceneSignal();
23465     } CALL_CATCH_EXCEPTION(0);
23466   }
23467
23468   jresult = (void *)result;
23469   return jresult;
23470 }
23471
23472
23473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnRelayoutSignal(void * jarg1) {
23474   void * jresult ;
23475   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23476   Dali::Actor::OnRelayoutSignalType *result = 0 ;
23477
23478   arg1 = (Dali::Actor *)jarg1;
23479   {
23480     try {
23481       result = (Dali::Actor::OnRelayoutSignalType *) &(arg1)->OnRelayoutSignal();
23482     } CALL_CATCH_EXCEPTION(0);
23483   }
23484
23485   jresult = (void *)result;
23486   return jresult;
23487 }
23488
23489
23490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_UnparentAndReset(void * jarg1) {
23491   Dali::Actor *arg1 = 0 ;
23492
23493   arg1 = (Dali::Actor *)jarg1;
23494   if (!arg1) {
23495     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
23496     return ;
23497   }
23498   {
23499     try {
23500       Dali::UnparentAndReset(*arg1);
23501     } CALL_CATCH_EXCEPTION();
23502   }
23503
23504 }
23505
23506
23507 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_ENABLE_get() {
23508   int jresult ;
23509   int result;
23510
23511   result = (int)Dali::Layer::Property::CLIPPING_ENABLE;
23512   jresult = (int)result;
23513   return jresult;
23514 }
23515
23516
23517 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_BOX_get() {
23518   int jresult ;
23519   int result;
23520
23521   result = (int)Dali::Layer::Property::CLIPPING_BOX;
23522   jresult = (int)result;
23523   return jresult;
23524 }
23525
23526
23527 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_BEHAVIOR_get() {
23528   int jresult ;
23529   int result;
23530
23531   result = (int)Dali::Layer::Property::BEHAVIOR;
23532   jresult = (int)result;
23533   return jresult;
23534 }
23535
23536
23537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer_Property() {
23538   void * jresult ;
23539   Dali::Layer::Property *result = 0 ;
23540
23541   {
23542     try {
23543       result = (Dali::Layer::Property *)new Dali::Layer::Property();
23544     } CALL_CATCH_EXCEPTION(0);
23545   }
23546
23547   jresult = (void *)result;
23548   return jresult;
23549 }
23550
23551
23552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer_Property(void * jarg1) {
23553   Dali::Layer::Property *arg1 = (Dali::Layer::Property *) 0 ;
23554
23555   arg1 = (Dali::Layer::Property *)jarg1;
23556   {
23557     try {
23558       delete arg1;
23559     } CALL_CATCH_EXCEPTION();
23560   }
23561
23562 }
23563
23564
23565 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_0() {
23566   void * jresult ;
23567   Dali::Layer *result = 0 ;
23568
23569   {
23570     try {
23571       result = (Dali::Layer *)new Dali::Layer();
23572     } CALL_CATCH_EXCEPTION(0);
23573   }
23574
23575   jresult = (void *)result;
23576   return jresult;
23577 }
23578
23579
23580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_New() {
23581   void * jresult ;
23582   Dali::Layer result;
23583
23584   {
23585     try {
23586       result = Dali::Layer::New();
23587     } CALL_CATCH_EXCEPTION(0);
23588   }
23589
23590   jresult = new Dali::Layer((const Dali::Layer &)result);
23591   return jresult;
23592 }
23593
23594
23595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_DownCast(void * jarg1) {
23596   void * jresult ;
23597   Dali::BaseHandle arg1 ;
23598   Dali::BaseHandle *argp1 ;
23599   Dali::Layer result;
23600
23601   argp1 = (Dali::BaseHandle *)jarg1;
23602   if (!argp1) {
23603     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
23604     return 0;
23605   }
23606   arg1 = *argp1;
23607   {
23608     try {
23609       result = Dali::Layer::DownCast(arg1);
23610     } CALL_CATCH_EXCEPTION(0);
23611   }
23612
23613   jresult = new Dali::Layer((const Dali::Layer &)result);
23614   return jresult;
23615 }
23616
23617
23618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer(void * jarg1) {
23619   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23620
23621   arg1 = (Dali::Layer *)jarg1;
23622   {
23623     try {
23624       delete arg1;
23625     } CALL_CATCH_EXCEPTION();
23626   }
23627
23628 }
23629
23630
23631 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_1(void * jarg1) {
23632   void * jresult ;
23633   Dali::Layer *arg1 = 0 ;
23634   Dali::Layer *result = 0 ;
23635
23636   arg1 = (Dali::Layer *)jarg1;
23637   if (!arg1) {
23638     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
23639     return 0;
23640   }
23641   {
23642     try {
23643       result = (Dali::Layer *)new Dali::Layer((Dali::Layer const &)*arg1);
23644     } CALL_CATCH_EXCEPTION(0);
23645   }
23646
23647   jresult = (void *)result;
23648   return jresult;
23649 }
23650
23651
23652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_Assign(void * jarg1, void * jarg2) {
23653   void * jresult ;
23654   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23655   Dali::Layer *arg2 = 0 ;
23656   Dali::Layer *result = 0 ;
23657
23658   arg1 = (Dali::Layer *)jarg1;
23659   arg2 = (Dali::Layer *)jarg2;
23660   if (!arg2) {
23661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
23662     return 0;
23663   }
23664   {
23665     try {
23666       result = (Dali::Layer *) &(arg1)->operator =((Dali::Layer const &)*arg2);
23667     } CALL_CATCH_EXCEPTION(0);
23668   }
23669
23670   jresult = (void *)result;
23671   return jresult;
23672 }
23673
23674
23675 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_GetDepth(void * jarg1) {
23676   unsigned int jresult ;
23677   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23678   unsigned int result;
23679
23680   arg1 = (Dali::Layer *)jarg1;
23681   {
23682     try {
23683       result = (unsigned int)((Dali::Layer const *)arg1)->GetProperty< int >( Layer::Property::DEPTH );
23684     } CALL_CATCH_EXCEPTION(0);
23685   }
23686
23687   jresult = result;
23688   return jresult;
23689 }
23690
23691
23692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Raise(void * jarg1) {
23693   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23694
23695   arg1 = (Dali::Layer *)jarg1;
23696   {
23697     try {
23698       (arg1)->Raise();
23699     } CALL_CATCH_EXCEPTION();
23700   }
23701
23702 }
23703
23704
23705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Lower(void * jarg1) {
23706   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23707
23708   arg1 = (Dali::Layer *)jarg1;
23709   {
23710     try {
23711       (arg1)->Lower();
23712     } CALL_CATCH_EXCEPTION();
23713   }
23714
23715 }
23716
23717
23718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseAbove(void * jarg1, void * jarg2) {
23719   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23720   Dali::Layer arg2 ;
23721   Dali::Layer *argp2 ;
23722
23723   arg1 = (Dali::Layer *)jarg1;
23724   argp2 = (Dali::Layer *)jarg2;
23725   if (!argp2) {
23726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
23727     return ;
23728   }
23729   arg2 = *argp2;
23730   {
23731     try {
23732       (arg1)->RaiseAbove(arg2);
23733     } CALL_CATCH_EXCEPTION();
23734   }
23735
23736 }
23737
23738
23739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerBelow(void * jarg1, void * jarg2) {
23740   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23741   Dali::Layer arg2 ;
23742   Dali::Layer *argp2 ;
23743
23744   arg1 = (Dali::Layer *)jarg1;
23745   argp2 = (Dali::Layer *)jarg2;
23746   if (!argp2) {
23747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
23748     return ;
23749   }
23750   arg2 = *argp2;
23751   {
23752     try {
23753       (arg1)->LowerBelow(arg2);
23754     } CALL_CATCH_EXCEPTION();
23755   }
23756
23757 }
23758
23759
23760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseToTop(void * jarg1) {
23761   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23762
23763   arg1 = (Dali::Layer *)jarg1;
23764   {
23765     try {
23766       (arg1)->RaiseToTop();
23767     } CALL_CATCH_EXCEPTION();
23768   }
23769
23770 }
23771
23772
23773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerToBottom(void * jarg1) {
23774   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23775
23776   arg1 = (Dali::Layer *)jarg1;
23777   {
23778     try {
23779       (arg1)->LowerToBottom();
23780     } CALL_CATCH_EXCEPTION();
23781   }
23782
23783 }
23784
23785
23786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveAbove(void * jarg1, void * jarg2) {
23787   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23788   Dali::Layer arg2 ;
23789   Dali::Layer *argp2 ;
23790
23791   arg1 = (Dali::Layer *)jarg1;
23792   argp2 = (Dali::Layer *)jarg2;
23793   if (!argp2) {
23794     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
23795     return ;
23796   }
23797   arg2 = *argp2;
23798   {
23799     try {
23800       (arg1)->MoveAbove(arg2);
23801     } CALL_CATCH_EXCEPTION();
23802   }
23803
23804 }
23805
23806
23807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveBelow(void * jarg1, void * jarg2) {
23808   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23809   Dali::Layer arg2 ;
23810   Dali::Layer *argp2 ;
23811
23812   arg1 = (Dali::Layer *)jarg1;
23813   argp2 = (Dali::Layer *)jarg2;
23814   if (!argp2) {
23815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
23816     return ;
23817   }
23818   arg2 = *argp2;
23819   {
23820     try {
23821       (arg1)->MoveBelow(arg2);
23822     } CALL_CATCH_EXCEPTION();
23823   }
23824
23825 }
23826
23827
23828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetBehavior(void * jarg1, int jarg2) {
23829   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23830   Dali::Layer::Behavior arg2 ;
23831
23832   arg1 = (Dali::Layer *)jarg1;
23833   arg2 = (Dali::Layer::Behavior)jarg2;
23834   {
23835     try {
23836       (arg1)->SetProperty( Layer::Property::BEHAVIOR, arg2 );
23837     } CALL_CATCH_EXCEPTION();
23838   }
23839
23840 }
23841
23842
23843 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_GetBehavior(void * jarg1) {
23844   int jresult ;
23845   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23846   Dali::Layer::Behavior result;
23847
23848   arg1 = (Dali::Layer *)jarg1;
23849   {
23850     try {
23851       result = (Dali::Layer::Behavior)((Dali::Layer const *)arg1)->GetProperty<Dali::Layer::Behavior>( Dali::Layer::Property::BEHAVIOR );
23852     } CALL_CATCH_EXCEPTION(0);
23853   }
23854
23855   jresult = (int)result;
23856   return jresult;
23857 }
23858
23859
23860 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClipping(void * jarg1, unsigned int jarg2) {
23861   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23862   bool arg2 ;
23863
23864   arg1 = (Dali::Layer *)jarg1;
23865   arg2 = jarg2 ? true : false;
23866   {
23867     try {
23868       (arg1)->SetProperty( Dali::Layer::Property::CLIPPING_ENABLE, arg2 );
23869     } CALL_CATCH_EXCEPTION();
23870   }
23871
23872 }
23873
23874
23875 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsClipping(void * jarg1) {
23876   unsigned int jresult ;
23877   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23878   bool result;
23879
23880   arg1 = (Dali::Layer *)jarg1;
23881   {
23882     try {
23883       result = (bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Dali::Layer::Property::CLIPPING_ENABLE );
23884     } CALL_CATCH_EXCEPTION(0);
23885   }
23886
23887   jresult = result;
23888   return jresult;
23889 }
23890
23891
23892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_0(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
23893   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23894   int arg2 ;
23895   int arg3 ;
23896   int arg4 ;
23897   int arg5 ;
23898
23899   arg1 = (Dali::Layer *)jarg1;
23900   arg2 = (int)jarg2;
23901   arg3 = (int)jarg3;
23902   arg4 = (int)jarg4;
23903   arg5 = (int)jarg5;
23904   {
23905     try {
23906       (arg1)->SetProperty( Dali::Layer::Property::CLIPPING_BOX, Rect<int32_t>( arg2,arg3,arg4,arg5 ) );
23907     } CALL_CATCH_EXCEPTION();
23908   }
23909
23910 }
23911
23912
23913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_1(void * jarg1, void * jarg2) {
23914   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23915   Dali::ClippingBox arg2 ;
23916   Dali::ClippingBox *argp2 ;
23917
23918   arg1 = (Dali::Layer *)jarg1;
23919   argp2 = (Dali::ClippingBox *)jarg2;
23920   if (!argp2) {
23921     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ClippingBox", 0);
23922     return ;
23923   }
23924   arg2 = *argp2;
23925   {
23926     try {
23927       (arg1)->SetProperty( Dali::Layer::Property::CLIPPING_BOX, arg2 );
23928     } CALL_CATCH_EXCEPTION();
23929   }
23930
23931 }
23932
23933
23934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_GetClippingBox(void * jarg1) {
23935   void * jresult ;
23936   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23937   Dali::ClippingBox result;
23938
23939   arg1 = (Dali::Layer *)jarg1;
23940   {
23941     try {
23942       result = ((Dali::Layer const *)arg1)->GetProperty< Rect<int32_t> >( Layer::Property::CLIPPING_BOX );
23943     } CALL_CATCH_EXCEPTION(0);
23944   }
23945
23946   jresult = new Dali::ClippingBox((const Dali::ClippingBox &)result);
23947   return jresult;
23948 }
23949
23950
23951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetDepthTestDisabled(void * jarg1, unsigned int jarg2) {
23952   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23953   bool arg2 ;
23954
23955   arg1 = (Dali::Layer *)jarg1;
23956   arg2 = jarg2 ? true : false;
23957   {
23958     try {
23959       (arg1)->SetProperty( Layer::Property::DEPTH_TEST, !arg2 );
23960     } CALL_CATCH_EXCEPTION();
23961   }
23962
23963 }
23964
23965
23966 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsDepthTestDisabled(void * jarg1) {
23967   unsigned int jresult ;
23968   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23969   bool result;
23970
23971   arg1 = (Dali::Layer *)jarg1;
23972   {
23973     try {
23974       result = !(bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Layer::Property::DEPTH_TEST );
23975     } CALL_CATCH_EXCEPTION(0);
23976   }
23977
23978   jresult = result;
23979   return jresult;
23980 }
23981
23982
23983 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetSortFunction(void * jarg1, void * jarg2) {
23984   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23985   Dali::Layer::SortFunctionType arg2 = (Dali::Layer::SortFunctionType) 0 ;
23986
23987   arg1 = (Dali::Layer *)jarg1;
23988   arg2 = (Dali::Layer::SortFunctionType)jarg2;
23989   {
23990     try {
23991       (arg1)->SetSortFunction(arg2);
23992     } CALL_CATCH_EXCEPTION();
23993   }
23994
23995 }
23996
23997
23998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetTouchConsumed(void * jarg1, unsigned int jarg2) {
23999   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
24000   bool arg2 ;
24001
24002   arg1 = (Dali::Layer *)jarg1;
24003   arg2 = jarg2 ? true : false;
24004   {
24005     try {
24006       (arg1)->SetProperty( Layer::Property::CONSUMES_TOUCH, arg2 );
24007     } CALL_CATCH_EXCEPTION();
24008   }
24009
24010 }
24011
24012
24013 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsTouchConsumed(void * jarg1) {
24014   unsigned int jresult ;
24015   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
24016   bool result;
24017
24018   arg1 = (Dali::Layer *)jarg1;
24019   {
24020     try {
24021       result = (bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Layer::Property::CONSUMES_TOUCH );
24022     } CALL_CATCH_EXCEPTION(0);
24023   }
24024
24025   jresult = result;
24026   return jresult;
24027 }
24028
24029
24030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetHoverConsumed(void * jarg1, unsigned int jarg2) {
24031   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
24032   bool arg2 ;
24033
24034   arg1 = (Dali::Layer *)jarg1;
24035   arg2 = jarg2 ? true : false;
24036   {
24037     try {
24038       (arg1)->SetProperty( Layer::Property::CONSUMES_HOVER, arg2 );
24039     } CALL_CATCH_EXCEPTION();
24040   }
24041
24042 }
24043
24044
24045 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsHoverConsumed(void * jarg1) {
24046   unsigned int jresult ;
24047   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
24048   bool result;
24049
24050   arg1 = (Dali::Layer *)jarg1;
24051   {
24052     try {
24053       result = (bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Layer::Property::CONSUMES_HOVER );
24054     } CALL_CATCH_EXCEPTION(0);
24055   }
24056
24057   jresult = result;
24058   return jresult;
24059 }
24060
24061
24062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetCurrent() {
24063   void * jresult ;
24064   Dali::Stage result;
24065
24066   {
24067     try {
24068       result = Dali::Stage::GetCurrent();
24069     } CALL_CATCH_EXCEPTION(0);
24070   }
24071
24072   jresult = new Dali::Stage((const Dali::Stage &)result);
24073   return jresult;
24074 }
24075
24076
24077 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_IsInstalled() {
24078   unsigned int jresult ;
24079   bool result;
24080
24081   {
24082     try {
24083       result = (bool)Dali::Stage::IsInstalled();
24084     } CALL_CATCH_EXCEPTION(0);
24085   }
24086
24087   jresult = result;
24088   return jresult;
24089 }
24090
24091
24092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetDpi(void * jarg1) {
24093   void * jresult ;
24094   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
24095   Dali::Vector2 result;
24096
24097   arg1 = (Dali::Stage *)jarg1;
24098   {
24099     try {
24100       result = ((Dali::Stage const *)arg1)->GetDpi();
24101     } CALL_CATCH_EXCEPTION(0);
24102   }
24103
24104   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
24105   return jresult;
24106 }
24107
24108
24109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_KeepRendering(void * jarg1, float jarg2) {
24110   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
24111   float arg2 ;
24112
24113   arg1 = (Dali::Stage *)jarg1;
24114   arg2 = (float)jarg2;
24115   {
24116     try {
24117       (arg1)->KeepRendering(arg2);
24118     } CALL_CATCH_EXCEPTION();
24119   }
24120
24121 }
24122
24123
24124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_KeyEventSignal(void * jarg1) {
24125   void * jresult ;
24126   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
24127   Dali::Stage::KeyEventSignalType *result = 0 ;
24128
24129   arg1 = (Dali::Stage *)jarg1;
24130   {
24131     try {
24132       result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal();
24133     } CALL_CATCH_EXCEPTION(0);
24134   }
24135
24136   jresult = (void *)result;
24137   return jresult;
24138 }
24139
24140
24141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_EventProcessingFinishedSignal(void * jarg1) {
24142   void * jresult ;
24143   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
24144   Dali::Stage::EventProcessingFinishedSignalType *result = 0 ;
24145
24146   arg1 = (Dali::Stage *)jarg1;
24147   {
24148     try {
24149       result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal();
24150     } CALL_CATCH_EXCEPTION(0);
24151   }
24152
24153   jresult = (void *)result;
24154   return jresult;
24155 }
24156
24157
24158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_TouchSignal(void * jarg1) {
24159   void * jresult ;
24160   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
24161   Dali::Stage::TouchSignalType *result = 0 ;
24162
24163   arg1 = (Dali::Stage *)jarg1;
24164   {
24165     try {
24166       result = (Dali::Stage::TouchSignalType *) &(arg1)->TouchSignal();
24167     } CALL_CATCH_EXCEPTION(0);
24168   }
24169
24170   jresult = (void *)result;
24171   return jresult;
24172 }
24173
24174
24175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_WheelEventSignal(void * jarg1) {
24176   void * jresult ;
24177   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
24178   Dali::Stage::WheelEventSignalType *result = 0 ;
24179
24180   arg1 = (Dali::Stage *)jarg1;
24181   {
24182     try {
24183       result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal();
24184     } CALL_CATCH_EXCEPTION(0);
24185   }
24186
24187   jresult = (void *)result;
24188   return jresult;
24189 }
24190
24191
24192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextLostSignal(void * jarg1) {
24193   void * jresult ;
24194   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
24195   Dali::Stage::ContextStatusSignal *result = 0 ;
24196
24197   arg1 = (Dali::Stage *)jarg1;
24198   {
24199     try {
24200       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal();
24201     } CALL_CATCH_EXCEPTION(0);
24202   }
24203
24204   jresult = (void *)result;
24205   return jresult;
24206 }
24207
24208
24209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextRegainedSignal(void * jarg1) {
24210   void * jresult ;
24211   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
24212   Dali::Stage::ContextStatusSignal *result = 0 ;
24213
24214   arg1 = (Dali::Stage *)jarg1;
24215   {
24216     try {
24217       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextRegainedSignal();
24218     } CALL_CATCH_EXCEPTION(0);
24219   }
24220
24221   jresult = (void *)result;
24222   return jresult;
24223 }
24224
24225
24226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_SceneCreatedSignal(void * jarg1) {
24227   void * jresult ;
24228   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
24229   Dali::Stage::SceneCreatedSignalType *result = 0 ;
24230
24231   arg1 = (Dali::Stage *)jarg1;
24232   {
24233     try {
24234       result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal();
24235     } CALL_CATCH_EXCEPTION(0);
24236   }
24237
24238   jresult = (void *)result;
24239   return jresult;
24240 }
24241
24242 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetRenderingBehavior(void * jarg1, int jarg2) {
24243   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
24244   Dali::DevelStage::Rendering arg2 ;
24245
24246   arg1 = (Dali::Stage *)jarg1;
24247   arg2 = (Dali::DevelStage::Rendering)jarg2;
24248   {
24249     try {
24250       DevelStage::SetRenderingBehavior(*arg1,arg2);
24251     } CALL_CATCH_EXCEPTION();
24252   }
24253
24254 }
24255
24256 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Stage_GetRenderingBehavior(void * jarg1) {
24257
24258   int jresult ;
24259   int result ;
24260   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
24261
24262   arg1 = (Dali::Stage *)jarg1;
24263   {
24264     try {
24265       result = (int)(DevelStage::GetRenderingBehavior(*arg1));
24266     } CALL_CATCH_EXCEPTION(0);
24267   }
24268
24269   jresult = result;
24270   return jresult;
24271 }
24272
24273 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RelayoutContainer(void * jarg1) {
24274   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
24275
24276   arg1 = (Dali::RelayoutContainer *)jarg1;
24277   {
24278     try {
24279       delete arg1;
24280     } CALL_CATCH_EXCEPTION();
24281   }
24282
24283 }
24284
24285
24286 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) {
24287   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
24288   Dali::Actor *arg2 = 0 ;
24289   Dali::Vector2 *arg3 = 0 ;
24290
24291   arg1 = (Dali::RelayoutContainer *)jarg1;
24292   arg2 = (Dali::Actor *)jarg2;
24293   if (!arg2) {
24294     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
24295     return ;
24296   }
24297   arg3 = (Dali::Vector2 *)jarg3;
24298   if (!arg3) {
24299     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
24300     return ;
24301   }
24302   {
24303     try {
24304       (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3);
24305     } CALL_CATCH_EXCEPTION();
24306   }
24307
24308 }
24309
24310
24311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_Self(void * jarg1) {
24312   void * jresult ;
24313   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24314   Dali::CustomActor result;
24315
24316   arg1 = (Dali::CustomActorImpl *)jarg1;
24317   {
24318     try {
24319       result = ((Dali::CustomActorImpl const *)arg1)->Self();
24320     } CALL_CATCH_EXCEPTION(0);
24321   }
24322
24323   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
24324   return jresult;
24325 }
24326
24327
24328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSceneConnection(void * jarg1, int jarg2) {
24329   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24330   int arg2 ;
24331
24332   arg1 = (Dali::CustomActorImpl *)jarg1;
24333   arg2 = (int)jarg2;
24334   {
24335     try {
24336       (arg1)->OnSceneConnection(arg2);
24337     } CALL_CATCH_EXCEPTION();
24338   }
24339
24340 }
24341
24342
24343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSceneDisconnection(void * jarg1) {
24344   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24345
24346   arg1 = (Dali::CustomActorImpl *)jarg1;
24347   {
24348     try {
24349       (arg1)->OnSceneDisconnection();
24350     } CALL_CATCH_EXCEPTION();
24351   }
24352
24353 }
24354
24355
24356 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildAdd(void * jarg1, void * jarg2) {
24357   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24358   Dali::Actor *arg2 = 0 ;
24359
24360   arg1 = (Dali::CustomActorImpl *)jarg1;
24361   arg2 = (Dali::Actor *)jarg2;
24362   if (!arg2) {
24363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
24364     return ;
24365   }
24366   {
24367     try {
24368       (arg1)->OnChildAdd(*arg2);
24369     } CALL_CATCH_EXCEPTION();
24370   }
24371
24372 }
24373
24374
24375 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) {
24376   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24377   Dali::Actor *arg2 = 0 ;
24378
24379   arg1 = (Dali::CustomActorImpl *)jarg1;
24380   arg2 = (Dali::Actor *)jarg2;
24381   if (!arg2) {
24382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
24383     return ;
24384   }
24385   {
24386     try {
24387       (arg1)->OnChildRemove(*arg2);
24388     } CALL_CATCH_EXCEPTION();
24389   }
24390
24391 }
24392
24393
24394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
24395   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24396   Dali::Property::Index arg2 ;
24397   Dali::Property::Value arg3 ;
24398   Dali::Property::Value *argp3 ;
24399
24400   arg1 = (Dali::CustomActorImpl *)jarg1;
24401   arg2 = (Dali::Property::Index)jarg2;
24402   argp3 = (Dali::Property::Value *)jarg3;
24403   if (!argp3) {
24404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
24405     return ;
24406   }
24407   arg3 = *argp3;
24408   {
24409     try {
24410       (arg1)->OnPropertySet(arg2,arg3);
24411     } CALL_CATCH_EXCEPTION();
24412   }
24413
24414 }
24415
24416
24417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeSet(void * jarg1, void * jarg2) {
24418   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24419   Dali::Vector3 *arg2 = 0 ;
24420
24421   arg1 = (Dali::CustomActorImpl *)jarg1;
24422   arg2 = (Dali::Vector3 *)jarg2;
24423   if (!arg2) {
24424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
24425     return ;
24426   }
24427   {
24428     try {
24429       (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2);
24430     } CALL_CATCH_EXCEPTION();
24431   }
24432
24433 }
24434
24435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
24436   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24437   Dali::Animation *arg2 = 0 ;
24438   Dali::Vector3 *arg3 = 0 ;
24439
24440   arg1 = (Dali::CustomActorImpl *)jarg1;
24441   arg2 = (Dali::Animation *)jarg2;
24442   if (!arg2) {
24443     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
24444     return ;
24445   }
24446   arg3 = (Dali::Vector3 *)jarg3;
24447   if (!arg3) {
24448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
24449     return ;
24450   }
24451   {
24452     try {
24453       (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
24454     } CALL_CATCH_EXCEPTION();
24455   }
24456 }
24457
24458 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnHoverEvent(void * jarg1, void * jarg2) {
24459   unsigned int jresult ;
24460   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24461   Dali::HoverEvent *arg2 = 0 ;
24462   bool result;
24463
24464   arg1 = (Dali::CustomActorImpl *)jarg1;
24465   arg2 = (Dali::HoverEvent *)jarg2;
24466   if (!arg2) {
24467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
24468     return 0;
24469   }
24470   {
24471     try {
24472       result = (bool)(arg1)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
24473     } CALL_CATCH_EXCEPTION(0);
24474   }
24475
24476   jresult = result;
24477   return jresult;
24478 }
24479
24480
24481 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnKeyEvent(void * jarg1, void * jarg2) {
24482   unsigned int jresult ;
24483   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24484   Dali::KeyEvent *arg2 = 0 ;
24485   bool result;
24486
24487   arg1 = (Dali::CustomActorImpl *)jarg1;
24488   arg2 = (Dali::KeyEvent *)jarg2;
24489   if (!arg2) {
24490     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
24491     return 0;
24492   }
24493   {
24494     try {
24495       result = (bool)(arg1)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
24496     } CALL_CATCH_EXCEPTION(0);
24497   }
24498
24499   jresult = result;
24500   return jresult;
24501 }
24502
24503
24504 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnWheelEvent(void * jarg1, void * jarg2) {
24505   unsigned int jresult ;
24506   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24507   Dali::WheelEvent *arg2 = 0 ;
24508   bool result;
24509
24510   arg1 = (Dali::CustomActorImpl *)jarg1;
24511   arg2 = (Dali::WheelEvent *)jarg2;
24512   if (!arg2) {
24513     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
24514     return 0;
24515   }
24516   {
24517     try {
24518       result = (bool)(arg1)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
24519     } CALL_CATCH_EXCEPTION(0);
24520   }
24521
24522   jresult = result;
24523   return jresult;
24524 }
24525
24526
24527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
24528   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24529   Dali::Vector2 *arg2 = 0 ;
24530   Dali::RelayoutContainer *arg3 = 0 ;
24531
24532   arg1 = (Dali::CustomActorImpl *)jarg1;
24533   arg2 = (Dali::Vector2 *)jarg2;
24534   if (!arg2) {
24535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
24536     return ;
24537   }
24538   arg3 = (Dali::RelayoutContainer *)jarg3;
24539   if (!arg3) {
24540     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
24541     return ;
24542   }
24543   {
24544     try {
24545       (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
24546     } CALL_CATCH_EXCEPTION();
24547   }
24548
24549 }
24550
24551
24552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
24553   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24554   Dali::ResizePolicy::Type arg2 ;
24555   Dali::Dimension::Type arg3 ;
24556
24557   arg1 = (Dali::CustomActorImpl *)jarg1;
24558   arg2 = (Dali::ResizePolicy::Type)jarg2;
24559   arg3 = (Dali::Dimension::Type)jarg3;
24560   {
24561     try {
24562       (arg1)->OnSetResizePolicy(arg2,arg3);
24563     } CALL_CATCH_EXCEPTION();
24564   }
24565
24566 }
24567
24568
24569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetNaturalSize(void * jarg1) {
24570   void * jresult ;
24571   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24572   Dali::Vector3 result;
24573
24574   arg1 = (Dali::CustomActorImpl *)jarg1;
24575   {
24576     try {
24577       result = (arg1)->GetNaturalSize();
24578     } CALL_CATCH_EXCEPTION(0);
24579   }
24580
24581   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
24582   return jresult;
24583 }
24584
24585
24586 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
24587   float jresult ;
24588   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24589   Dali::Actor *arg2 = 0 ;
24590   Dali::Dimension::Type arg3 ;
24591   float result;
24592
24593   arg1 = (Dali::CustomActorImpl *)jarg1;
24594   arg2 = (Dali::Actor *)jarg2;
24595   if (!arg2) {
24596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
24597     return 0;
24598   }
24599   arg3 = (Dali::Dimension::Type)jarg3;
24600   {
24601     try {
24602       result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
24603     } CALL_CATCH_EXCEPTION(0);
24604   }
24605
24606   jresult = result;
24607   return jresult;
24608 }
24609
24610
24611 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) {
24612   float jresult ;
24613   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24614   float arg2 ;
24615   float result;
24616
24617   arg1 = (Dali::CustomActorImpl *)jarg1;
24618   arg2 = (float)jarg2;
24619   {
24620     try {
24621       result = (float)(arg1)->GetHeightForWidth(arg2);
24622     } CALL_CATCH_EXCEPTION(0);
24623   }
24624
24625   jresult = result;
24626   return jresult;
24627 }
24628
24629
24630 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) {
24631   float jresult ;
24632   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24633   float arg2 ;
24634   float result;
24635
24636   arg1 = (Dali::CustomActorImpl *)jarg1;
24637   arg2 = (float)jarg2;
24638   {
24639     try {
24640       result = (float)(arg1)->GetWidthForHeight(arg2);
24641     } CALL_CATCH_EXCEPTION(0);
24642   }
24643
24644   jresult = result;
24645   return jresult;
24646 }
24647
24648
24649 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
24650   unsigned int jresult ;
24651   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24652   Dali::Dimension::Type arg2 ;
24653   bool result;
24654
24655   arg1 = (Dali::CustomActorImpl *)jarg1;
24656   arg2 = (Dali::Dimension::Type)jarg2;
24657   {
24658     try {
24659       result = (bool)(arg1)->RelayoutDependentOnChildren(arg2);
24660     } CALL_CATCH_EXCEPTION(0);
24661   }
24662
24663   jresult = result;
24664   return jresult;
24665 }
24666
24667
24668 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
24669   unsigned int jresult ;
24670   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24671   bool result;
24672
24673   arg1 = (Dali::CustomActorImpl *)jarg1;
24674   {
24675     try {
24676       result = (bool)(arg1)->RelayoutDependentOnChildren();
24677     } CALL_CATCH_EXCEPTION(0);
24678   }
24679
24680   jresult = result;
24681   return jresult;
24682 }
24683
24684
24685 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
24686   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24687   Dali::Dimension::Type arg2 ;
24688
24689   arg1 = (Dali::CustomActorImpl *)jarg1;
24690   arg2 = (Dali::Dimension::Type)jarg2;
24691   {
24692     try {
24693       (arg1)->OnCalculateRelayoutSize(arg2);
24694     } CALL_CATCH_EXCEPTION();
24695   }
24696
24697 }
24698
24699
24700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
24701   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24702   float arg2 ;
24703   Dali::Dimension::Type arg3 ;
24704
24705   arg1 = (Dali::CustomActorImpl *)jarg1;
24706   arg2 = (float)jarg2;
24707   arg3 = (Dali::Dimension::Type)jarg3;
24708   {
24709     try {
24710       (arg1)->OnLayoutNegotiated(arg2,arg3);
24711     } CALL_CATCH_EXCEPTION();
24712   }
24713
24714 }
24715
24716
24717 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresTouchEvents(void * jarg1) {
24718   unsigned int jresult ;
24719   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24720   bool result;
24721
24722   arg1 = (Dali::CustomActorImpl *)jarg1;
24723   {
24724     try {
24725       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresTouchEvents();
24726     } CALL_CATCH_EXCEPTION(0);
24727   }
24728
24729   jresult = result;
24730   return jresult;
24731 }
24732
24733
24734 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresHoverEvents(void * jarg1) {
24735   unsigned int jresult ;
24736   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24737   bool result;
24738
24739   arg1 = (Dali::CustomActorImpl *)jarg1;
24740   {
24741     try {
24742       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresHoverEvents();
24743     } CALL_CATCH_EXCEPTION(0);
24744   }
24745
24746   jresult = result;
24747   return jresult;
24748 }
24749
24750
24751 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresWheelEvents(void * jarg1) {
24752   unsigned int jresult ;
24753   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24754   bool result;
24755
24756   arg1 = (Dali::CustomActorImpl *)jarg1;
24757   {
24758     try {
24759       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresWheelEvents();
24760     } CALL_CATCH_EXCEPTION(0);
24761   }
24762
24763   jresult = result;
24764   return jresult;
24765 }
24766
24767
24768 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_IsRelayoutEnabled(void * jarg1) {
24769   unsigned int jresult ;
24770   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24771   bool result;
24772
24773   arg1 = (Dali::CustomActorImpl *)jarg1;
24774   {
24775     try {
24776       result = (bool)((Dali::CustomActorImpl const *)arg1)->IsRelayoutEnabled();
24777     } CALL_CATCH_EXCEPTION(0);
24778   }
24779
24780   jresult = result;
24781   return jresult;
24782 }
24783
24784
24785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_0() {
24786   void * jresult ;
24787   Dali::CustomActor *result = 0 ;
24788
24789   {
24790     try {
24791       result = (Dali::CustomActor *)new Dali::CustomActor();
24792     } CALL_CATCH_EXCEPTION(0);
24793   }
24794
24795   jresult = (void *)result;
24796   return jresult;
24797 }
24798
24799
24800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_DownCast(void * jarg1) {
24801   void * jresult ;
24802   Dali::BaseHandle arg1 ;
24803   Dali::BaseHandle *argp1 ;
24804   Dali::CustomActor result;
24805
24806   argp1 = (Dali::BaseHandle *)jarg1;
24807   if (!argp1) {
24808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24809     return 0;
24810   }
24811   arg1 = *argp1;
24812   {
24813     try {
24814       result = Dali::CustomActor::DownCast(arg1);
24815     } CALL_CATCH_EXCEPTION(0);
24816   }
24817
24818   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
24819   return jresult;
24820 }
24821
24822
24823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomActor(void * jarg1) {
24824   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
24825
24826   arg1 = (Dali::CustomActor *)jarg1;
24827   {
24828     try {
24829       delete arg1;
24830     } CALL_CATCH_EXCEPTION();
24831   }
24832
24833 }
24834
24835
24836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_GetImplementation(void * jarg1) {
24837   void * jresult ;
24838   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
24839   Dali::CustomActorImpl *result = 0 ;
24840
24841   arg1 = (Dali::CustomActor *)jarg1;
24842   {
24843     try {
24844       result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation();
24845     } CALL_CATCH_EXCEPTION(0);
24846   }
24847
24848   jresult = (void *)result;
24849   return jresult;
24850 }
24851
24852
24853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_1(void * jarg1) {
24854   void * jresult ;
24855   Dali::CustomActorImpl *arg1 = 0 ;
24856   Dali::CustomActor *result = 0 ;
24857
24858   arg1 = (Dali::CustomActorImpl *)jarg1;
24859   if (!arg1) {
24860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0);
24861     return 0;
24862   }
24863   {
24864     try {
24865       result = (Dali::CustomActor *)new Dali::CustomActor(*arg1);
24866     } CALL_CATCH_EXCEPTION(0);
24867   }
24868
24869   jresult = (void *)result;
24870   return jresult;
24871 }
24872
24873
24874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_2(void * jarg1) {
24875   void * jresult ;
24876   Dali::CustomActor *arg1 = 0 ;
24877   Dali::CustomActor *result = 0 ;
24878
24879   arg1 = (Dali::CustomActor *)jarg1;
24880   if (!arg1) {
24881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
24882     return 0;
24883   }
24884   {
24885     try {
24886       result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*arg1);
24887     } CALL_CATCH_EXCEPTION(0);
24888   }
24889
24890   jresult = (void *)result;
24891   return jresult;
24892 }
24893
24894
24895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_Assign(void * jarg1, void * jarg2) {
24896   void * jresult ;
24897   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
24898   Dali::CustomActor *arg2 = 0 ;
24899   Dali::CustomActor *result = 0 ;
24900
24901   arg1 = (Dali::CustomActor *)jarg1;
24902   arg2 = (Dali::CustomActor *)jarg2;
24903   if (!arg2) {
24904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
24905     return 0;
24906   }
24907   {
24908     try {
24909       result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2);
24910     } CALL_CATCH_EXCEPTION(0);
24911   }
24912
24913   jresult = (void *)result;
24914   return jresult;
24915 }
24916
24917
24918 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_POSITION_get() {
24919   int jresult ;
24920   int result;
24921
24922   result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION;
24923   jresult = (int)result;
24924   return jresult;
24925 }
24926
24927
24928 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() {
24929   int jresult ;
24930   int result;
24931
24932   result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT;
24933   jresult = (int)result;
24934   return jresult;
24935 }
24936
24937
24938 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_VELOCITY_get() {
24939   int jresult ;
24940   int result;
24941
24942   result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY;
24943   jresult = (int)result;
24944   return jresult;
24945 }
24946
24947
24948 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_POSITION_get() {
24949   int jresult ;
24950   int result;
24951
24952   result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION;
24953   jresult = (int)result;
24954   return jresult;
24955 }
24956
24957
24958 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() {
24959   int jresult ;
24960   int result;
24961
24962   result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT;
24963   jresult = (int)result;
24964   return jresult;
24965 }
24966
24967
24968 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_VELOCITY_get() {
24969   int jresult ;
24970   int result;
24971
24972   result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY;
24973   jresult = (int)result;
24974   return jresult;
24975 }
24976
24977
24978 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_PANNING_get() {
24979   int jresult ;
24980   int result;
24981
24982   result = (int)Dali::PanGestureDetector::Property::PANNING;
24983   jresult = (int)result;
24984   return jresult;
24985 }
24986
24987
24988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector_Property() {
24989   void * jresult ;
24990   Dali::PanGestureDetector::Property *result = 0 ;
24991
24992   {
24993     try {
24994       result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property();
24995     } CALL_CATCH_EXCEPTION(0);
24996   }
24997
24998   jresult = (void *)result;
24999   return jresult;
25000 }
25001
25002
25003 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector_Property(void * jarg1) {
25004   Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ;
25005
25006   arg1 = (Dali::PanGestureDetector::Property *)jarg1;
25007   {
25008     try {
25009       delete arg1;
25010     } CALL_CATCH_EXCEPTION();
25011   }
25012
25013 }
25014
25015
25016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_LEFT_get() {
25017   void * jresult ;
25018   Dali::Radian *result = 0 ;
25019
25020   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT;
25021   jresult = (void *)result;
25022   return jresult;
25023 }
25024
25025
25026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_RIGHT_get() {
25027   void * jresult ;
25028   Dali::Radian *result = 0 ;
25029
25030   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT;
25031   jresult = (void *)result;
25032   return jresult;
25033 }
25034
25035
25036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_UP_get() {
25037   void * jresult ;
25038   Dali::Radian *result = 0 ;
25039
25040   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP;
25041   jresult = (void *)result;
25042   return jresult;
25043 }
25044
25045
25046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_DOWN_get() {
25047   void * jresult ;
25048   Dali::Radian *result = 0 ;
25049
25050   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN;
25051   jresult = (void *)result;
25052   return jresult;
25053 }
25054
25055
25056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_HORIZONTAL_get() {
25057   void * jresult ;
25058   Dali::Radian *result = 0 ;
25059
25060   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL;
25061   jresult = (void *)result;
25062   return jresult;
25063 }
25064
25065
25066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_VERTICAL_get() {
25067   void * jresult ;
25068   Dali::Radian *result = 0 ;
25069
25070   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL;
25071   jresult = (void *)result;
25072   return jresult;
25073 }
25074
25075
25076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DEFAULT_THRESHOLD_get() {
25077   void * jresult ;
25078   Dali::Radian *result = 0 ;
25079
25080   result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD;
25081   jresult = (void *)result;
25082   return jresult;
25083 }
25084
25085
25086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_0() {
25087   void * jresult ;
25088   Dali::PanGestureDetector *result = 0 ;
25089
25090   {
25091     try {
25092       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector();
25093     } CALL_CATCH_EXCEPTION(0);
25094   }
25095
25096   jresult = (void *)result;
25097   return jresult;
25098 }
25099
25100
25101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_New() {
25102   void * jresult ;
25103   Dali::PanGestureDetector result;
25104
25105   {
25106     try {
25107       result = Dali::PanGestureDetector::New();
25108     } CALL_CATCH_EXCEPTION(0);
25109   }
25110
25111   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
25112   return jresult;
25113 }
25114
25115
25116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DownCast(void * jarg1) {
25117   void * jresult ;
25118   Dali::BaseHandle arg1 ;
25119   Dali::BaseHandle *argp1 ;
25120   Dali::PanGestureDetector result;
25121
25122   argp1 = (Dali::BaseHandle *)jarg1;
25123   if (!argp1) {
25124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25125     return 0;
25126   }
25127   arg1 = *argp1;
25128   {
25129     try {
25130       result = Dali::PanGestureDetector::DownCast(arg1);
25131     } CALL_CATCH_EXCEPTION(0);
25132   }
25133
25134   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
25135   return jresult;
25136 }
25137
25138
25139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector(void * jarg1) {
25140   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25141
25142   arg1 = (Dali::PanGestureDetector *)jarg1;
25143   {
25144     try {
25145       delete arg1;
25146     } CALL_CATCH_EXCEPTION();
25147   }
25148
25149 }
25150
25151
25152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_1(void * jarg1) {
25153   void * jresult ;
25154   Dali::PanGestureDetector *arg1 = 0 ;
25155   Dali::PanGestureDetector *result = 0 ;
25156
25157   arg1 = (Dali::PanGestureDetector *)jarg1;
25158   if (!arg1) {
25159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
25160     return 0;
25161   }
25162   {
25163     try {
25164       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1);
25165     } CALL_CATCH_EXCEPTION(0);
25166   }
25167
25168   jresult = (void *)result;
25169   return jresult;
25170 }
25171
25172
25173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_Assign(void * jarg1, void * jarg2) {
25174   void * jresult ;
25175   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25176   Dali::PanGestureDetector *arg2 = 0 ;
25177   Dali::PanGestureDetector *result = 0 ;
25178
25179   arg1 = (Dali::PanGestureDetector *)jarg1;
25180   arg2 = (Dali::PanGestureDetector *)jarg2;
25181   if (!arg2) {
25182     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
25183     return 0;
25184   }
25185   {
25186     try {
25187       result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2);
25188     } CALL_CATCH_EXCEPTION(0);
25189   }
25190
25191   jresult = (void *)result;
25192   return jresult;
25193 }
25194
25195
25196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) {
25197   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25198   unsigned int arg2 ;
25199
25200   arg1 = (Dali::PanGestureDetector *)jarg1;
25201   arg2 = (unsigned int)jarg2;
25202   {
25203     try {
25204       (arg1)->SetMinimumTouchesRequired(arg2);
25205     } CALL_CATCH_EXCEPTION();
25206   }
25207
25208 }
25209
25210
25211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) {
25212   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25213   unsigned int arg2 ;
25214
25215   arg1 = (Dali::PanGestureDetector *)jarg1;
25216   arg2 = (unsigned int)jarg2;
25217   {
25218     try {
25219       (arg1)->SetMaximumTouchesRequired(arg2);
25220     } CALL_CATCH_EXCEPTION();
25221   }
25222
25223 }
25224
25225
25226 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
25227   unsigned int jresult ;
25228   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25229   unsigned int result;
25230
25231   arg1 = (Dali::PanGestureDetector *)jarg1;
25232   {
25233     try {
25234       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired();
25235     } CALL_CATCH_EXCEPTION(0);
25236   }
25237
25238   jresult = result;
25239   return jresult;
25240 }
25241
25242
25243 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
25244   unsigned int jresult ;
25245   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25246   unsigned int result;
25247
25248   arg1 = (Dali::PanGestureDetector *)jarg1;
25249   {
25250     try {
25251       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMaximumTouchesRequired();
25252     } CALL_CATCH_EXCEPTION(0);
25253   }
25254
25255   jresult = result;
25256   return jresult;
25257 }
25258
25259
25260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
25261   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25262   Dali::Radian arg2 ;
25263   Dali::Radian arg3 ;
25264   Dali::Radian *argp2 ;
25265   Dali::Radian *argp3 ;
25266
25267   arg1 = (Dali::PanGestureDetector *)jarg1;
25268   argp2 = (Dali::Radian *)jarg2;
25269   if (!argp2) {
25270     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
25271     return ;
25272   }
25273   arg2 = *argp2;
25274   argp3 = (Dali::Radian *)jarg3;
25275   if (!argp3) {
25276     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
25277     return ;
25278   }
25279   arg3 = *argp3;
25280   {
25281     try {
25282       (arg1)->AddAngle(arg2,arg3);
25283     } CALL_CATCH_EXCEPTION();
25284   }
25285
25286 }
25287
25288
25289 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) {
25290   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25291   Dali::Radian arg2 ;
25292   Dali::Radian *argp2 ;
25293
25294   arg1 = (Dali::PanGestureDetector *)jarg1;
25295   argp2 = (Dali::Radian *)jarg2;
25296   if (!argp2) {
25297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
25298     return ;
25299   }
25300   arg2 = *argp2;
25301   {
25302     try {
25303       (arg1)->AddAngle(arg2);
25304     } CALL_CATCH_EXCEPTION();
25305   }
25306
25307 }
25308
25309
25310 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
25311   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25312   Dali::Radian arg2 ;
25313   Dali::Radian arg3 ;
25314   Dali::Radian *argp2 ;
25315   Dali::Radian *argp3 ;
25316
25317   arg1 = (Dali::PanGestureDetector *)jarg1;
25318   argp2 = (Dali::Radian *)jarg2;
25319   if (!argp2) {
25320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
25321     return ;
25322   }
25323   arg2 = *argp2;
25324   argp3 = (Dali::Radian *)jarg3;
25325   if (!argp3) {
25326     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
25327     return ;
25328   }
25329   arg3 = *argp3;
25330   {
25331     try {
25332       (arg1)->AddDirection(arg2,arg3);
25333     } CALL_CATCH_EXCEPTION();
25334   }
25335
25336 }
25337
25338
25339 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) {
25340   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25341   Dali::Radian arg2 ;
25342   Dali::Radian *argp2 ;
25343
25344   arg1 = (Dali::PanGestureDetector *)jarg1;
25345   argp2 = (Dali::Radian *)jarg2;
25346   if (!argp2) {
25347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
25348     return ;
25349   }
25350   arg2 = *argp2;
25351   {
25352     try {
25353       (arg1)->AddDirection(arg2);
25354     } CALL_CATCH_EXCEPTION();
25355   }
25356
25357 }
25358
25359
25360 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngleCount(void * jarg1) {
25361   unsigned long jresult ;
25362   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25363   size_t result;
25364
25365   arg1 = (Dali::PanGestureDetector *)jarg1;
25366   {
25367     try {
25368       result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount();
25369     } CALL_CATCH_EXCEPTION(0);
25370   }
25371
25372   jresult = (unsigned long)result;
25373   return jresult;
25374 }
25375
25376
25377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) {
25378   void * jresult ;
25379   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25380   size_t arg2 ;
25381   Dali::PanGestureDetector::AngleThresholdPair result;
25382
25383   arg1 = (Dali::PanGestureDetector *)jarg1;
25384   arg2 = (size_t)jarg2;
25385   {
25386     try {
25387       result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2);
25388     } CALL_CATCH_EXCEPTION(0);
25389   }
25390
25391   jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result);
25392   return jresult;
25393 }
25394
25395
25396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_ClearAngles(void * jarg1) {
25397   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25398
25399   arg1 = (Dali::PanGestureDetector *)jarg1;
25400   {
25401     try {
25402       (arg1)->ClearAngles();
25403     } CALL_CATCH_EXCEPTION();
25404   }
25405
25406 }
25407
25408
25409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) {
25410   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25411   Dali::Radian arg2 ;
25412   Dali::Radian *argp2 ;
25413
25414   arg1 = (Dali::PanGestureDetector *)jarg1;
25415   argp2 = (Dali::Radian *)jarg2;
25416   if (!argp2) {
25417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
25418     return ;
25419   }
25420   arg2 = *argp2;
25421   {
25422     try {
25423       (arg1)->RemoveAngle(arg2);
25424     } CALL_CATCH_EXCEPTION();
25425   }
25426
25427 }
25428
25429
25430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveDirection(void * jarg1, void * jarg2) {
25431   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25432   Dali::Radian arg2 ;
25433   Dali::Radian *argp2 ;
25434
25435   arg1 = (Dali::PanGestureDetector *)jarg1;
25436   argp2 = (Dali::Radian *)jarg2;
25437   if (!argp2) {
25438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
25439     return ;
25440   }
25441   arg2 = *argp2;
25442   {
25443     try {
25444       (arg1)->RemoveDirection(arg2);
25445     } CALL_CATCH_EXCEPTION();
25446   }
25447
25448 }
25449
25450
25451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DetectedSignal(void * jarg1) {
25452   void * jresult ;
25453   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25454   Dali::PanGestureDetector::DetectedSignalType *result = 0 ;
25455
25456   arg1 = (Dali::PanGestureDetector *)jarg1;
25457   {
25458     try {
25459       result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
25460     } CALL_CATCH_EXCEPTION(0);
25461   }
25462
25463   jresult = (void *)result;
25464   return jresult;
25465 }
25466
25467
25468 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetPanGestureProperties(void * jarg1) {
25469   Dali::PanGesture *arg1 = 0 ;
25470
25471   arg1 = (Dali::PanGesture *)jarg1;
25472   if (!arg1) {
25473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
25474     return ;
25475   }
25476   {
25477     try {
25478       Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1);
25479     } CALL_CATCH_EXCEPTION();
25480   }
25481
25482 }
25483
25484
25485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_0() {
25486   void * jresult ;
25487   Dali::PanGesture *result = 0 ;
25488
25489   {
25490     try {
25491       result = (Dali::PanGesture *)new Dali::PanGesture();
25492     } CALL_CATCH_EXCEPTION(0);
25493   }
25494
25495   jresult = (void *)result;
25496   return jresult;
25497 }
25498
25499
25500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_1(int jarg1) {
25501   void * jresult ;
25502   Dali::Gesture::State arg1 ;
25503   Dali::PanGesture *result = 0 ;
25504
25505   arg1 = (Dali::Gesture::State)jarg1;
25506   {
25507     try {
25508       result = (Dali::PanGesture *)new Dali::PanGesture(arg1);
25509     } CALL_CATCH_EXCEPTION(0);
25510   }
25511
25512   jresult = (void *)result;
25513   return jresult;
25514 }
25515
25516
25517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_2(void * jarg1) {
25518   void * jresult ;
25519   Dali::PanGesture *arg1 = 0 ;
25520   Dali::PanGesture *result = 0 ;
25521
25522   arg1 = (Dali::PanGesture *)jarg1;
25523   if (!arg1) {
25524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
25525     return 0;
25526   }
25527   {
25528     try {
25529       result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*arg1);
25530     } CALL_CATCH_EXCEPTION(0);
25531   }
25532
25533   jresult = (void *)result;
25534   return jresult;
25535 }
25536
25537
25538 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_Assign(void * jarg1, void * jarg2) {
25539   void * jresult ;
25540   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
25541   Dali::PanGesture *arg2 = 0 ;
25542   Dali::PanGesture *result = 0 ;
25543
25544   arg1 = (Dali::PanGesture *)jarg1;
25545   arg2 = (Dali::PanGesture *)jarg2;
25546   if (!arg2) {
25547     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
25548     return 0;
25549   }
25550   {
25551     try {
25552       result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2);
25553     } CALL_CATCH_EXCEPTION(0);
25554   }
25555
25556   jresult = (void *)result;
25557   return jresult;
25558 }
25559
25560
25561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGesture(void * jarg1) {
25562   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
25563
25564   arg1 = (Dali::PanGesture *)jarg1;
25565   {
25566     try {
25567       delete arg1;
25568     } CALL_CATCH_EXCEPTION();
25569   }
25570
25571 }
25572
25573
25574 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_velocity_set(void * jarg1, void * jarg2) {
25575   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
25576   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
25577
25578   arg1 = (Dali::PanGesture *)jarg1;
25579   arg2 = (Dali::Vector2 *)jarg2;
25580   if (arg1) (arg1)->velocity = *arg2;
25581 }
25582
25583
25584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_velocity_get(void * jarg1) {
25585   void * jresult ;
25586   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
25587   Dali::Vector2 *result = 0 ;
25588
25589   arg1 = (Dali::PanGesture *)jarg1;
25590   result = (Dali::Vector2 *)& ((arg1)->velocity);
25591   jresult = (void *)result;
25592   return jresult;
25593 }
25594
25595
25596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_displacement_set(void * jarg1, void * jarg2) {
25597   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
25598   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
25599
25600   arg1 = (Dali::PanGesture *)jarg1;
25601   arg2 = (Dali::Vector2 *)jarg2;
25602   if (arg1) (arg1)->displacement = *arg2;
25603 }
25604
25605
25606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_displacement_get(void * jarg1) {
25607   void * jresult ;
25608   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
25609   Dali::Vector2 *result = 0 ;
25610
25611   arg1 = (Dali::PanGesture *)jarg1;
25612   result = (Dali::Vector2 *)& ((arg1)->displacement);
25613   jresult = (void *)result;
25614   return jresult;
25615 }
25616
25617
25618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_position_set(void * jarg1, void * jarg2) {
25619   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
25620   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
25621
25622   arg1 = (Dali::PanGesture *)jarg1;
25623   arg2 = (Dali::Vector2 *)jarg2;
25624   if (arg1) (arg1)->position = *arg2;
25625 }
25626
25627
25628 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_position_get(void * jarg1) {
25629   void * jresult ;
25630   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
25631   Dali::Vector2 *result = 0 ;
25632
25633   arg1 = (Dali::PanGesture *)jarg1;
25634   result = (Dali::Vector2 *)& ((arg1)->position);
25635   jresult = (void *)result;
25636   return jresult;
25637 }
25638
25639
25640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_set(void * jarg1, void * jarg2) {
25641   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
25642   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
25643
25644   arg1 = (Dali::PanGesture *)jarg1;
25645   arg2 = (Dali::Vector2 *)jarg2;
25646   if (arg1) (arg1)->screenVelocity = *arg2;
25647 }
25648
25649
25650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_get(void * jarg1) {
25651   void * jresult ;
25652   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
25653   Dali::Vector2 *result = 0 ;
25654
25655   arg1 = (Dali::PanGesture *)jarg1;
25656   result = (Dali::Vector2 *)& ((arg1)->screenVelocity);
25657   jresult = (void *)result;
25658   return jresult;
25659 }
25660
25661
25662 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_set(void * jarg1, void * jarg2) {
25663   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
25664   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
25665
25666   arg1 = (Dali::PanGesture *)jarg1;
25667   arg2 = (Dali::Vector2 *)jarg2;
25668   if (arg1) (arg1)->screenDisplacement = *arg2;
25669 }
25670
25671
25672 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_get(void * jarg1) {
25673   void * jresult ;
25674   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
25675   Dali::Vector2 *result = 0 ;
25676
25677   arg1 = (Dali::PanGesture *)jarg1;
25678   result = (Dali::Vector2 *)& ((arg1)->screenDisplacement);
25679   jresult = (void *)result;
25680   return jresult;
25681 }
25682
25683
25684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_set(void * jarg1, void * jarg2) {
25685   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
25686   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
25687
25688   arg1 = (Dali::PanGesture *)jarg1;
25689   arg2 = (Dali::Vector2 *)jarg2;
25690   if (arg1) (arg1)->screenPosition = *arg2;
25691 }
25692
25693
25694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_get(void * jarg1) {
25695   void * jresult ;
25696   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
25697   Dali::Vector2 *result = 0 ;
25698
25699   arg1 = (Dali::PanGesture *)jarg1;
25700   result = (Dali::Vector2 *)& ((arg1)->screenPosition);
25701   jresult = (void *)result;
25702   return jresult;
25703 }
25704
25705
25706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
25707   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
25708   unsigned int arg2 ;
25709
25710   arg1 = (Dali::PanGesture *)jarg1;
25711   arg2 = (unsigned int)jarg2;
25712   if (arg1) (arg1)->numberOfTouches = arg2;
25713 }
25714
25715
25716 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_get(void * jarg1) {
25717   unsigned int jresult ;
25718   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
25719   unsigned int result;
25720
25721   arg1 = (Dali::PanGesture *)jarg1;
25722   result = (unsigned int) ((arg1)->numberOfTouches);
25723   jresult = result;
25724   return jresult;
25725 }
25726
25727
25728 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetSpeed(void * jarg1) {
25729   float jresult ;
25730   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
25731   float result;
25732
25733   arg1 = (Dali::PanGesture *)jarg1;
25734   {
25735     try {
25736       result = (float)((Dali::PanGesture const *)arg1)->GetSpeed();
25737     } CALL_CATCH_EXCEPTION(0);
25738   }
25739
25740   jresult = result;
25741   return jresult;
25742 }
25743
25744
25745 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetDistance(void * jarg1) {
25746   float jresult ;
25747   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
25748   float result;
25749
25750   arg1 = (Dali::PanGesture *)jarg1;
25751   {
25752     try {
25753       result = (float)((Dali::PanGesture const *)arg1)->GetDistance();
25754     } CALL_CATCH_EXCEPTION(0);
25755   }
25756
25757   jresult = result;
25758   return jresult;
25759 }
25760
25761
25762 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenSpeed(void * jarg1) {
25763   float jresult ;
25764   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
25765   float result;
25766
25767   arg1 = (Dali::PanGesture *)jarg1;
25768   {
25769     try {
25770       result = (float)((Dali::PanGesture const *)arg1)->GetScreenSpeed();
25771     } CALL_CATCH_EXCEPTION(0);
25772   }
25773
25774   jresult = result;
25775   return jresult;
25776 }
25777
25778
25779 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenDistance(void * jarg1) {
25780   float jresult ;
25781   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
25782   float result;
25783
25784   arg1 = (Dali::PanGesture *)jarg1;
25785   {
25786     try {
25787       result = (float)((Dali::PanGesture const *)arg1)->GetScreenDistance();
25788     } CALL_CATCH_EXCEPTION(0);
25789   }
25790
25791   jresult = result;
25792   return jresult;
25793 }
25794
25795
25796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_0() {
25797   void * jresult ;
25798   Dali::PinchGestureDetector *result = 0 ;
25799
25800   {
25801     try {
25802       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector();
25803     } CALL_CATCH_EXCEPTION(0);
25804   }
25805
25806   jresult = (void *)result;
25807   return jresult;
25808 }
25809
25810
25811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_New() {
25812   void * jresult ;
25813   Dali::PinchGestureDetector result;
25814
25815   {
25816     try {
25817       result = Dali::PinchGestureDetector::New();
25818     } CALL_CATCH_EXCEPTION(0);
25819   }
25820
25821   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
25822   return jresult;
25823 }
25824
25825
25826 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DownCast(void * jarg1) {
25827   void * jresult ;
25828   Dali::BaseHandle arg1 ;
25829   Dali::BaseHandle *argp1 ;
25830   Dali::PinchGestureDetector result;
25831
25832   argp1 = (Dali::BaseHandle *)jarg1;
25833   if (!argp1) {
25834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25835     return 0;
25836   }
25837   arg1 = *argp1;
25838   {
25839     try {
25840       result = Dali::PinchGestureDetector::DownCast(arg1);
25841     } CALL_CATCH_EXCEPTION(0);
25842   }
25843
25844   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
25845   return jresult;
25846 }
25847
25848
25849 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetector(void * jarg1) {
25850   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
25851
25852   arg1 = (Dali::PinchGestureDetector *)jarg1;
25853   {
25854     try {
25855       delete arg1;
25856     } CALL_CATCH_EXCEPTION();
25857   }
25858
25859 }
25860
25861
25862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_1(void * jarg1) {
25863   void * jresult ;
25864   Dali::PinchGestureDetector *arg1 = 0 ;
25865   Dali::PinchGestureDetector *result = 0 ;
25866
25867   arg1 = (Dali::PinchGestureDetector *)jarg1;
25868   if (!arg1) {
25869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
25870     return 0;
25871   }
25872   {
25873     try {
25874       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1);
25875     } CALL_CATCH_EXCEPTION(0);
25876   }
25877
25878   jresult = (void *)result;
25879   return jresult;
25880 }
25881
25882
25883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_Assign(void * jarg1, void * jarg2) {
25884   void * jresult ;
25885   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
25886   Dali::PinchGestureDetector *arg2 = 0 ;
25887   Dali::PinchGestureDetector *result = 0 ;
25888
25889   arg1 = (Dali::PinchGestureDetector *)jarg1;
25890   arg2 = (Dali::PinchGestureDetector *)jarg2;
25891   if (!arg2) {
25892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
25893     return 0;
25894   }
25895   {
25896     try {
25897       result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2);
25898     } CALL_CATCH_EXCEPTION(0);
25899   }
25900
25901   jresult = (void *)result;
25902   return jresult;
25903 }
25904
25905
25906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DetectedSignal(void * jarg1) {
25907   void * jresult ;
25908   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
25909   Dali::PinchGestureDetector::DetectedSignalType *result = 0 ;
25910
25911   arg1 = (Dali::PinchGestureDetector *)jarg1;
25912   {
25913     try {
25914       result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
25915     } CALL_CATCH_EXCEPTION(0);
25916   }
25917
25918   jresult = (void *)result;
25919   return jresult;
25920 }
25921
25922
25923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_0(int jarg1) {
25924   void * jresult ;
25925   Dali::Gesture::State arg1 ;
25926   Dali::PinchGesture *result = 0 ;
25927
25928   arg1 = (Dali::Gesture::State)jarg1;
25929   {
25930     try {
25931       result = (Dali::PinchGesture *)new Dali::PinchGesture(arg1);
25932     } CALL_CATCH_EXCEPTION(0);
25933   }
25934
25935   jresult = (void *)result;
25936   return jresult;
25937 }
25938
25939
25940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_1(void * jarg1) {
25941   void * jresult ;
25942   Dali::PinchGesture *arg1 = 0 ;
25943   Dali::PinchGesture *result = 0 ;
25944
25945   arg1 = (Dali::PinchGesture *)jarg1;
25946   if (!arg1) {
25947     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
25948     return 0;
25949   }
25950   {
25951     try {
25952       result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*arg1);
25953     } CALL_CATCH_EXCEPTION(0);
25954   }
25955
25956   jresult = (void *)result;
25957   return jresult;
25958 }
25959
25960
25961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_Assign(void * jarg1, void * jarg2) {
25962   void * jresult ;
25963   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
25964   Dali::PinchGesture *arg2 = 0 ;
25965   Dali::PinchGesture *result = 0 ;
25966
25967   arg1 = (Dali::PinchGesture *)jarg1;
25968   arg2 = (Dali::PinchGesture *)jarg2;
25969   if (!arg2) {
25970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
25971     return 0;
25972   }
25973   {
25974     try {
25975       result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2);
25976     } CALL_CATCH_EXCEPTION(0);
25977   }
25978
25979   jresult = (void *)result;
25980   return jresult;
25981 }
25982
25983
25984 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGesture(void * jarg1) {
25985   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
25986
25987   arg1 = (Dali::PinchGesture *)jarg1;
25988   {
25989     try {
25990       delete arg1;
25991     } CALL_CATCH_EXCEPTION();
25992   }
25993
25994 }
25995
25996
25997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_scale_set(void * jarg1, float jarg2) {
25998   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
25999   float arg2 ;
26000
26001   arg1 = (Dali::PinchGesture *)jarg1;
26002   arg2 = (float)jarg2;
26003   if (arg1) (arg1)->scale = arg2;
26004 }
26005
26006
26007 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_scale_get(void * jarg1) {
26008   float jresult ;
26009   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
26010   float result;
26011
26012   arg1 = (Dali::PinchGesture *)jarg1;
26013   result = (float) ((arg1)->scale);
26014   jresult = result;
26015   return jresult;
26016 }
26017
26018
26019 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_speed_set(void * jarg1, float jarg2) {
26020   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
26021   float arg2 ;
26022
26023   arg1 = (Dali::PinchGesture *)jarg1;
26024   arg2 = (float)jarg2;
26025   if (arg1) (arg1)->speed = arg2;
26026 }
26027
26028
26029 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_speed_get(void * jarg1) {
26030   float jresult ;
26031   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
26032   float result;
26033
26034   arg1 = (Dali::PinchGesture *)jarg1;
26035   result = (float) ((arg1)->speed);
26036   jresult = result;
26037   return jresult;
26038 }
26039
26040
26041 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_set(void * jarg1, void * jarg2) {
26042   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
26043   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
26044
26045   arg1 = (Dali::PinchGesture *)jarg1;
26046   arg2 = (Dali::Vector2 *)jarg2;
26047   if (arg1) (arg1)->screenCenterPoint = *arg2;
26048 }
26049
26050
26051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_get(void * jarg1) {
26052   void * jresult ;
26053   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
26054   Dali::Vector2 *result = 0 ;
26055
26056   arg1 = (Dali::PinchGesture *)jarg1;
26057   result = (Dali::Vector2 *)& ((arg1)->screenCenterPoint);
26058   jresult = (void *)result;
26059   return jresult;
26060 }
26061
26062
26063 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_set(void * jarg1, void * jarg2) {
26064   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
26065   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
26066
26067   arg1 = (Dali::PinchGesture *)jarg1;
26068   arg2 = (Dali::Vector2 *)jarg2;
26069   if (arg1) (arg1)->localCenterPoint = *arg2;
26070 }
26071
26072
26073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_get(void * jarg1) {
26074   void * jresult ;
26075   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
26076   Dali::Vector2 *result = 0 ;
26077
26078   arg1 = (Dali::PinchGesture *)jarg1;
26079   result = (Dali::Vector2 *)& ((arg1)->localCenterPoint);
26080   jresult = (void *)result;
26081   return jresult;
26082 }
26083
26084
26085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_0() {
26086   void * jresult ;
26087   Dali::TapGestureDetector *result = 0 ;
26088
26089   {
26090     try {
26091       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector();
26092     } CALL_CATCH_EXCEPTION(0);
26093   }
26094
26095   jresult = (void *)result;
26096   return jresult;
26097 }
26098
26099
26100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_0() {
26101   void * jresult ;
26102   Dali::TapGestureDetector result;
26103
26104   {
26105     try {
26106       result = Dali::TapGestureDetector::New();
26107     } CALL_CATCH_EXCEPTION(0);
26108   }
26109
26110   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
26111   return jresult;
26112 }
26113
26114
26115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_1(unsigned int jarg1) {
26116   void * jresult ;
26117   unsigned int arg1 ;
26118   Dali::TapGestureDetector result;
26119
26120   arg1 = (unsigned int)jarg1;
26121   {
26122     try {
26123       result = Dali::TapGestureDetector::New(arg1);
26124     } CALL_CATCH_EXCEPTION(0);
26125   }
26126
26127   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
26128   return jresult;
26129 }
26130
26131
26132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DownCast(void * jarg1) {
26133   void * jresult ;
26134   Dali::BaseHandle arg1 ;
26135   Dali::BaseHandle *argp1 ;
26136   Dali::TapGestureDetector result;
26137
26138   argp1 = (Dali::BaseHandle *)jarg1;
26139   if (!argp1) {
26140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26141     return 0;
26142   }
26143   arg1 = *argp1;
26144   {
26145     try {
26146       result = Dali::TapGestureDetector::DownCast(arg1);
26147     } CALL_CATCH_EXCEPTION(0);
26148   }
26149
26150   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
26151   return jresult;
26152 }
26153
26154
26155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetector(void * jarg1) {
26156   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
26157
26158   arg1 = (Dali::TapGestureDetector *)jarg1;
26159   {
26160     try {
26161       delete arg1;
26162     } CALL_CATCH_EXCEPTION();
26163   }
26164
26165 }
26166
26167
26168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_1(void * jarg1) {
26169   void * jresult ;
26170   Dali::TapGestureDetector *arg1 = 0 ;
26171   Dali::TapGestureDetector *result = 0 ;
26172
26173   arg1 = (Dali::TapGestureDetector *)jarg1;
26174   if (!arg1) {
26175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
26176     return 0;
26177   }
26178   {
26179     try {
26180       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1);
26181     } CALL_CATCH_EXCEPTION(0);
26182   }
26183
26184   jresult = (void *)result;
26185   return jresult;
26186 }
26187
26188
26189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_Assign(void * jarg1, void * jarg2) {
26190   void * jresult ;
26191   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
26192   Dali::TapGestureDetector *arg2 = 0 ;
26193   Dali::TapGestureDetector *result = 0 ;
26194
26195   arg1 = (Dali::TapGestureDetector *)jarg1;
26196   arg2 = (Dali::TapGestureDetector *)jarg2;
26197   if (!arg2) {
26198     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
26199     return 0;
26200   }
26201   {
26202     try {
26203       result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2);
26204     } CALL_CATCH_EXCEPTION(0);
26205   }
26206
26207   jresult = (void *)result;
26208   return jresult;
26209 }
26210
26211
26212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) {
26213   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
26214   unsigned int arg2 ;
26215
26216   arg1 = (Dali::TapGestureDetector *)jarg1;
26217   arg2 = (unsigned int)jarg2;
26218   {
26219     try {
26220       (arg1)->SetMinimumTapsRequired(arg2);
26221     } CALL_CATCH_EXCEPTION();
26222   }
26223
26224 }
26225
26226
26227 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) {
26228   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
26229   unsigned int arg2 ;
26230
26231   arg1 = (Dali::TapGestureDetector *)jarg1;
26232   arg2 = (unsigned int)jarg2;
26233   {
26234     try {
26235       (arg1)->SetMaximumTapsRequired(arg2);
26236     } CALL_CATCH_EXCEPTION();
26237   }
26238
26239 }
26240
26241
26242 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) {
26243   unsigned int jresult ;
26244   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
26245   unsigned int result;
26246
26247   arg1 = (Dali::TapGestureDetector *)jarg1;
26248   {
26249     try {
26250       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired();
26251     } CALL_CATCH_EXCEPTION(0);
26252   }
26253
26254   jresult = result;
26255   return jresult;
26256 }
26257
26258
26259 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMaximumTapsRequired(void * jarg1) {
26260   unsigned int jresult ;
26261   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
26262   unsigned int result;
26263
26264   arg1 = (Dali::TapGestureDetector *)jarg1;
26265   {
26266     try {
26267       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMaximumTapsRequired();
26268     } CALL_CATCH_EXCEPTION(0);
26269   }
26270
26271   jresult = result;
26272   return jresult;
26273 }
26274
26275
26276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DetectedSignal(void * jarg1) {
26277   void * jresult ;
26278   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
26279   Dali::TapGestureDetector::DetectedSignalType *result = 0 ;
26280
26281   arg1 = (Dali::TapGestureDetector *)jarg1;
26282   {
26283     try {
26284       result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
26285     } CALL_CATCH_EXCEPTION(0);
26286   }
26287
26288   jresult = (void *)result;
26289   return jresult;
26290 }
26291
26292
26293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_0() {
26294   void * jresult ;
26295   Dali::TapGesture *result = 0 ;
26296
26297   {
26298     try {
26299       result = (Dali::TapGesture *)new Dali::TapGesture();
26300     } CALL_CATCH_EXCEPTION(0);
26301   }
26302
26303   jresult = (void *)result;
26304   return jresult;
26305 }
26306
26307
26308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_1(void * jarg1) {
26309   void * jresult ;
26310   Dali::TapGesture *arg1 = 0 ;
26311   Dali::TapGesture *result = 0 ;
26312
26313   arg1 = (Dali::TapGesture *)jarg1;
26314   if (!arg1) {
26315     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
26316     return 0;
26317   }
26318   {
26319     try {
26320       result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1);
26321     } CALL_CATCH_EXCEPTION(0);
26322   }
26323
26324   jresult = (void *)result;
26325   return jresult;
26326 }
26327
26328
26329 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_Assign(void * jarg1, void * jarg2) {
26330   void * jresult ;
26331   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
26332   Dali::TapGesture *arg2 = 0 ;
26333   Dali::TapGesture *result = 0 ;
26334
26335   arg1 = (Dali::TapGesture *)jarg1;
26336   arg2 = (Dali::TapGesture *)jarg2;
26337   if (!arg2) {
26338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
26339     return 0;
26340   }
26341   {
26342     try {
26343       result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2);
26344     } CALL_CATCH_EXCEPTION(0);
26345   }
26346
26347   jresult = (void *)result;
26348   return jresult;
26349 }
26350
26351
26352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGesture(void * jarg1) {
26353   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
26354
26355   arg1 = (Dali::TapGesture *)jarg1;
26356   {
26357     try {
26358       delete arg1;
26359     } CALL_CATCH_EXCEPTION();
26360   }
26361
26362 }
26363
26364
26365 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_set(void * jarg1, unsigned int jarg2) {
26366   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
26367   unsigned int arg2 ;
26368
26369   arg1 = (Dali::TapGesture *)jarg1;
26370   arg2 = (unsigned int)jarg2;
26371   if (arg1) (arg1)->numberOfTaps = arg2;
26372 }
26373
26374
26375 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_get(void * jarg1) {
26376   unsigned int jresult ;
26377   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
26378   unsigned int result;
26379
26380   arg1 = (Dali::TapGesture *)jarg1;
26381   result = (unsigned int) ((arg1)->numberOfTaps);
26382   jresult = result;
26383   return jresult;
26384 }
26385
26386
26387 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
26388   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
26389   unsigned int arg2 ;
26390
26391   arg1 = (Dali::TapGesture *)jarg1;
26392   arg2 = (unsigned int)jarg2;
26393   if (arg1) (arg1)->numberOfTouches = arg2;
26394 }
26395
26396
26397 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_get(void * jarg1) {
26398   unsigned int jresult ;
26399   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
26400   unsigned int result;
26401
26402   arg1 = (Dali::TapGesture *)jarg1;
26403   result = (unsigned int) ((arg1)->numberOfTouches);
26404   jresult = result;
26405   return jresult;
26406 }
26407
26408
26409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_set(void * jarg1, void * jarg2) {
26410   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
26411   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
26412
26413   arg1 = (Dali::TapGesture *)jarg1;
26414   arg2 = (Dali::Vector2 *)jarg2;
26415   if (arg1) (arg1)->screenPoint = *arg2;
26416 }
26417
26418
26419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_get(void * jarg1) {
26420   void * jresult ;
26421   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
26422   Dali::Vector2 *result = 0 ;
26423
26424   arg1 = (Dali::TapGesture *)jarg1;
26425   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
26426   jresult = (void *)result;
26427   return jresult;
26428 }
26429
26430
26431 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_set(void * jarg1, void * jarg2) {
26432   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
26433   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
26434
26435   arg1 = (Dali::TapGesture *)jarg1;
26436   arg2 = (Dali::Vector2 *)jarg2;
26437   if (arg1) (arg1)->localPoint = *arg2;
26438 }
26439
26440
26441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_get(void * jarg1) {
26442   void * jresult ;
26443   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
26444   Dali::Vector2 *result = 0 ;
26445
26446   arg1 = (Dali::TapGesture *)jarg1;
26447   result = (Dali::Vector2 *)& ((arg1)->localPoint);
26448   jresult = (void *)result;
26449   return jresult;
26450 }
26451
26452
26453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_0() {
26454   void * jresult ;
26455   Dali::AlphaFunction *result = 0 ;
26456
26457   {
26458     try {
26459       result = (Dali::AlphaFunction *)new Dali::AlphaFunction();
26460     } CALL_CATCH_EXCEPTION(0);
26461   }
26462
26463   jresult = (void *)result;
26464   return jresult;
26465 }
26466
26467
26468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_1(int jarg1) {
26469   void * jresult ;
26470   Dali::AlphaFunction::BuiltinFunction arg1 ;
26471   Dali::AlphaFunction *result = 0 ;
26472
26473   arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1;
26474   {
26475     try {
26476       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
26477     } CALL_CATCH_EXCEPTION(0);
26478   }
26479
26480   jresult = (void *)result;
26481   return jresult;
26482 }
26483
26484
26485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_2(void * jarg1) {
26486   void * jresult ;
26487   Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ;
26488   Dali::AlphaFunction *result = 0 ;
26489
26490   arg1 = (Dali::AlphaFunctionPrototype)jarg1;
26491   {
26492     try {
26493       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
26494     } CALL_CATCH_EXCEPTION(0);
26495   }
26496
26497   jresult = (void *)result;
26498   return jresult;
26499 }
26500
26501
26502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_3(void * jarg1, void * jarg2) {
26503   void * jresult ;
26504   Dali::Vector2 *arg1 = 0 ;
26505   Dali::Vector2 *arg2 = 0 ;
26506   Dali::AlphaFunction *result = 0 ;
26507
26508   arg1 = (Dali::Vector2 *)jarg1;
26509   if (!arg1) {
26510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
26511     return 0;
26512   }
26513   arg2 = (Dali::Vector2 *)jarg2;
26514   if (!arg2) {
26515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
26516     return 0;
26517   }
26518   {
26519     try {
26520       result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
26521     } CALL_CATCH_EXCEPTION(0);
26522   }
26523
26524   jresult = (void *)result;
26525   return jresult;
26526 }
26527
26528
26529 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBezierControlPoints(void * jarg1) {
26530   void * jresult ;
26531   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
26532   Dali::Vector4 result;
26533
26534   arg1 = (Dali::AlphaFunction *)jarg1;
26535   {
26536     try {
26537       result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints();
26538     } CALL_CATCH_EXCEPTION(0);
26539   }
26540
26541   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
26542   return jresult;
26543 }
26544
26545
26546 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetCustomFunction(void * jarg1) {
26547   void * jresult ;
26548   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
26549   Dali::AlphaFunctionPrototype result;
26550
26551   arg1 = (Dali::AlphaFunction *)jarg1;
26552   {
26553     try {
26554       result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction();
26555     } CALL_CATCH_EXCEPTION(0);
26556   }
26557
26558   jresult = (void *)result;
26559   return jresult;
26560 }
26561
26562
26563 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBuiltinFunction(void * jarg1) {
26564   int jresult ;
26565   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
26566   Dali::AlphaFunction::BuiltinFunction result;
26567
26568   arg1 = (Dali::AlphaFunction *)jarg1;
26569   {
26570     try {
26571       result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction();
26572     } CALL_CATCH_EXCEPTION(0);
26573   }
26574
26575   jresult = (int)result;
26576   return jresult;
26577 }
26578
26579
26580 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetMode(void * jarg1) {
26581   int jresult ;
26582   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
26583   Dali::AlphaFunction::Mode result;
26584
26585   arg1 = (Dali::AlphaFunction *)jarg1;
26586   {
26587     try {
26588       result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode();
26589     } CALL_CATCH_EXCEPTION(0);
26590   }
26591
26592   jresult = (int)result;
26593   return jresult;
26594 }
26595
26596
26597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AlphaFunction(void * jarg1) {
26598   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
26599
26600   arg1 = (Dali::AlphaFunction *)jarg1;
26601   {
26602     try {
26603       delete arg1;
26604     } CALL_CATCH_EXCEPTION();
26605   }
26606
26607 }
26608
26609
26610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_New() {
26611   void * jresult ;
26612   Dali::KeyFrames result;
26613
26614   {
26615     try {
26616       result = Dali::KeyFrames::New();
26617     } CALL_CATCH_EXCEPTION(0);
26618   }
26619
26620   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
26621   return jresult;
26622 }
26623
26624
26625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_DownCast(void * jarg1) {
26626   void * jresult ;
26627   Dali::BaseHandle arg1 ;
26628   Dali::BaseHandle *argp1 ;
26629   Dali::KeyFrames result;
26630
26631   argp1 = (Dali::BaseHandle *)jarg1;
26632   if (!argp1) {
26633     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26634     return 0;
26635   }
26636   arg1 = *argp1;
26637   {
26638     try {
26639       result = Dali::KeyFrames::DownCast(arg1);
26640     } CALL_CATCH_EXCEPTION(0);
26641   }
26642
26643   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
26644   return jresult;
26645 }
26646
26647
26648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_0() {
26649   void * jresult ;
26650   Dali::KeyFrames *result = 0 ;
26651
26652   {
26653     try {
26654       result = (Dali::KeyFrames *)new Dali::KeyFrames();
26655     } CALL_CATCH_EXCEPTION(0);
26656   }
26657
26658   jresult = (void *)result;
26659   return jresult;
26660 }
26661
26662
26663 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyFrames(void * jarg1) {
26664   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
26665
26666   arg1 = (Dali::KeyFrames *)jarg1;
26667   {
26668     try {
26669       delete arg1;
26670     } CALL_CATCH_EXCEPTION();
26671   }
26672
26673 }
26674
26675
26676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_1(void * jarg1) {
26677   void * jresult ;
26678   Dali::KeyFrames *arg1 = 0 ;
26679   Dali::KeyFrames *result = 0 ;
26680
26681   arg1 = (Dali::KeyFrames *)jarg1;
26682   if (!arg1) {
26683     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
26684     return 0;
26685   }
26686   {
26687     try {
26688       result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1);
26689     } CALL_CATCH_EXCEPTION(0);
26690   }
26691
26692   jresult = (void *)result;
26693   return jresult;
26694 }
26695
26696
26697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_Assign(void * jarg1, void * jarg2) {
26698   void * jresult ;
26699   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
26700   Dali::KeyFrames *arg2 = 0 ;
26701   Dali::KeyFrames *result = 0 ;
26702
26703   arg1 = (Dali::KeyFrames *)jarg1;
26704   arg2 = (Dali::KeyFrames *)jarg2;
26705   if (!arg2) {
26706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
26707     return 0;
26708   }
26709   {
26710     try {
26711       result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2);
26712     } CALL_CATCH_EXCEPTION(0);
26713   }
26714
26715   jresult = (void *)result;
26716   return jresult;
26717 }
26718
26719
26720 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_KeyFrames_GetType(void * jarg1) {
26721   int jresult ;
26722   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
26723   Dali::Property::Type result;
26724
26725   arg1 = (Dali::KeyFrames *)jarg1;
26726   {
26727     try {
26728       result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType();
26729     } CALL_CATCH_EXCEPTION(0);
26730   }
26731
26732   jresult = (int)result;
26733   return jresult;
26734 }
26735
26736
26737 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) {
26738   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
26739   float arg2 ;
26740   Dali::Property::Value arg3 ;
26741   Dali::Property::Value *argp3 ;
26742
26743   arg1 = (Dali::KeyFrames *)jarg1;
26744   arg2 = (float)jarg2;
26745   argp3 = (Dali::Property::Value *)jarg3;
26746   if (!argp3) {
26747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
26748     return ;
26749   }
26750   arg3 = *argp3;
26751   {
26752     try {
26753       (arg1)->Add(arg2,arg3);
26754     } CALL_CATCH_EXCEPTION();
26755   }
26756
26757 }
26758
26759
26760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
26761   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
26762   float arg2 ;
26763   Dali::Property::Value arg3 ;
26764   Dali::AlphaFunction arg4 ;
26765   Dali::Property::Value *argp3 ;
26766   Dali::AlphaFunction *argp4 ;
26767
26768   arg1 = (Dali::KeyFrames *)jarg1;
26769   arg2 = (float)jarg2;
26770   argp3 = (Dali::Property::Value *)jarg3;
26771   if (!argp3) {
26772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
26773     return ;
26774   }
26775   arg3 = *argp3;
26776   argp4 = (Dali::AlphaFunction *)jarg4;
26777   if (!argp4) {
26778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
26779     return ;
26780   }
26781   arg4 = *argp4;
26782   {
26783     try {
26784       (arg1)->Add(arg2,arg3,arg4);
26785     } CALL_CATCH_EXCEPTION();
26786   }
26787
26788 }
26789
26790
26791 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_POINTS_get() {
26792   int jresult ;
26793   int result;
26794
26795   result = (int)Dali::Path::Property::POINTS;
26796   jresult = (int)result;
26797   return jresult;
26798 }
26799
26800
26801 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_CONTROL_POINTS_get() {
26802   int jresult ;
26803   int result;
26804
26805   result = (int)Dali::Path::Property::CONTROL_POINTS;
26806   jresult = (int)result;
26807   return jresult;
26808 }
26809
26810
26811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path_Property() {
26812   void * jresult ;
26813   Dali::Path::Property *result = 0 ;
26814
26815   {
26816     try {
26817       result = (Dali::Path::Property *)new Dali::Path::Property();
26818     } CALL_CATCH_EXCEPTION(0);
26819   }
26820
26821   jresult = (void *)result;
26822   return jresult;
26823 }
26824
26825
26826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path_Property(void * jarg1) {
26827   Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ;
26828
26829   arg1 = (Dali::Path::Property *)jarg1;
26830   {
26831     try {
26832       delete arg1;
26833     } CALL_CATCH_EXCEPTION();
26834   }
26835
26836 }
26837
26838
26839 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_New() {
26840   void * jresult ;
26841   Dali::Path result;
26842
26843   {
26844     try {
26845       result = Dali::Path::New();
26846     } CALL_CATCH_EXCEPTION(0);
26847   }
26848
26849   jresult = new Dali::Path((const Dali::Path &)result);
26850   return jresult;
26851 }
26852
26853
26854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_DownCast(void * jarg1) {
26855   void * jresult ;
26856   Dali::BaseHandle arg1 ;
26857   Dali::BaseHandle *argp1 ;
26858   Dali::Path result;
26859
26860   argp1 = (Dali::BaseHandle *)jarg1;
26861   if (!argp1) {
26862     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26863     return 0;
26864   }
26865   arg1 = *argp1;
26866   {
26867     try {
26868       result = Dali::Path::DownCast(arg1);
26869     } CALL_CATCH_EXCEPTION(0);
26870   }
26871
26872   jresult = new Dali::Path((const Dali::Path &)result);
26873   return jresult;
26874 }
26875
26876
26877 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_0() {
26878   void * jresult ;
26879   Dali::Path *result = 0 ;
26880
26881   {
26882     try {
26883       result = (Dali::Path *)new Dali::Path();
26884     } CALL_CATCH_EXCEPTION(0);
26885   }
26886
26887   jresult = (void *)result;
26888   return jresult;
26889 }
26890
26891
26892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path(void * jarg1) {
26893   Dali::Path *arg1 = (Dali::Path *) 0 ;
26894
26895   arg1 = (Dali::Path *)jarg1;
26896   {
26897     try {
26898       delete arg1;
26899     } CALL_CATCH_EXCEPTION();
26900   }
26901
26902 }
26903
26904
26905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_1(void * jarg1) {
26906   void * jresult ;
26907   Dali::Path *arg1 = 0 ;
26908   Dali::Path *result = 0 ;
26909
26910   arg1 = (Dali::Path *)jarg1;
26911   if (!arg1) {
26912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
26913     return 0;
26914   }
26915   {
26916     try {
26917       result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1);
26918     } CALL_CATCH_EXCEPTION(0);
26919   }
26920
26921   jresult = (void *)result;
26922   return jresult;
26923 }
26924
26925
26926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_Assign(void * jarg1, void * jarg2) {
26927   void * jresult ;
26928   Dali::Path *arg1 = (Dali::Path *) 0 ;
26929   Dali::Path *arg2 = 0 ;
26930   Dali::Path *result = 0 ;
26931
26932   arg1 = (Dali::Path *)jarg1;
26933   arg2 = (Dali::Path *)jarg2;
26934   if (!arg2) {
26935     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
26936     return 0;
26937   }
26938   {
26939     try {
26940       result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2);
26941     } CALL_CATCH_EXCEPTION(0);
26942   }
26943
26944   jresult = (void *)result;
26945   return jresult;
26946 }
26947
26948
26949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddPoint(void * jarg1, void * jarg2) {
26950   Dali::Path *arg1 = (Dali::Path *) 0 ;
26951   Dali::Vector3 *arg2 = 0 ;
26952
26953   arg1 = (Dali::Path *)jarg1;
26954   arg2 = (Dali::Vector3 *)jarg2;
26955   if (!arg2) {
26956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
26957     return ;
26958   }
26959   {
26960     try {
26961       (arg1)->AddPoint((Dali::Vector3 const &)*arg2);
26962     } CALL_CATCH_EXCEPTION();
26963   }
26964
26965 }
26966
26967
26968 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddControlPoint(void * jarg1, void * jarg2) {
26969   Dali::Path *arg1 = (Dali::Path *) 0 ;
26970   Dali::Vector3 *arg2 = 0 ;
26971
26972   arg1 = (Dali::Path *)jarg1;
26973   arg2 = (Dali::Vector3 *)jarg2;
26974   if (!arg2) {
26975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
26976     return ;
26977   }
26978   {
26979     try {
26980       (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2);
26981     } CALL_CATCH_EXCEPTION();
26982   }
26983
26984 }
26985
26986
26987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_GenerateControlPoints(void * jarg1, float jarg2) {
26988   Dali::Path *arg1 = (Dali::Path *) 0 ;
26989   float arg2 ;
26990
26991   arg1 = (Dali::Path *)jarg1;
26992   arg2 = (float)jarg2;
26993   {
26994     try {
26995       (arg1)->GenerateControlPoints(arg2);
26996     } CALL_CATCH_EXCEPTION();
26997   }
26998
26999 }
27000
27001
27002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
27003   Dali::Path *arg1 = (Dali::Path *) 0 ;
27004   float arg2 ;
27005   Dali::Vector3 *arg3 = 0 ;
27006   Dali::Vector3 *arg4 = 0 ;
27007
27008   arg1 = (Dali::Path *)jarg1;
27009   arg2 = (float)jarg2;
27010   arg3 = (Dali::Vector3 *)jarg3;
27011   if (!arg3) {
27012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
27013     return ;
27014   }
27015   arg4 = (Dali::Vector3 *)jarg4;
27016   if (!arg4) {
27017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
27018     return ;
27019   }
27020   {
27021     try {
27022       ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4);
27023     } CALL_CATCH_EXCEPTION();
27024   }
27025
27026 }
27027
27028
27029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetPoint(void * jarg1, unsigned long jarg2) {
27030   void * jresult ;
27031   Dali::Path *arg1 = (Dali::Path *) 0 ;
27032   size_t arg2 ;
27033   Dali::Vector3 *result = 0 ;
27034
27035   arg1 = (Dali::Path *)jarg1;
27036   arg2 = (size_t)jarg2;
27037   {
27038     try {
27039       result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2);
27040     } CALL_CATCH_EXCEPTION(0);
27041   }
27042
27043   jresult = (void *)result;
27044   return jresult;
27045 }
27046
27047
27048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetControlPoint(void * jarg1, unsigned long jarg2) {
27049   void * jresult ;
27050   Dali::Path *arg1 = (Dali::Path *) 0 ;
27051   size_t arg2 ;
27052   Dali::Vector3 *result = 0 ;
27053
27054   arg1 = (Dali::Path *)jarg1;
27055   arg2 = (size_t)jarg2;
27056   {
27057     try {
27058       result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2);
27059     } CALL_CATCH_EXCEPTION(0);
27060   }
27061
27062   jresult = (void *)result;
27063   return jresult;
27064 }
27065
27066
27067 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Path_GetPointCount(void * jarg1) {
27068   unsigned long jresult ;
27069   Dali::Path *arg1 = (Dali::Path *) 0 ;
27070   size_t result;
27071
27072   arg1 = (Dali::Path *)jarg1;
27073   {
27074     try {
27075       result = ((Dali::Path const *)arg1)->GetPointCount();
27076     } CALL_CATCH_EXCEPTION(0);
27077   }
27078
27079   jresult = (unsigned long)result;
27080   return jresult;
27081 }
27082
27083
27084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_0(float jarg1) {
27085   void * jresult ;
27086   float arg1 ;
27087   Dali::TimePeriod *result = 0 ;
27088
27089   arg1 = (float)jarg1;
27090   {
27091     try {
27092       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1);
27093     } CALL_CATCH_EXCEPTION(0);
27094   }
27095
27096   jresult = (void *)result;
27097   return jresult;
27098 }
27099
27100
27101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_1(float jarg1, float jarg2) {
27102   void * jresult ;
27103   float arg1 ;
27104   float arg2 ;
27105   Dali::TimePeriod *result = 0 ;
27106
27107   arg1 = (float)jarg1;
27108   arg2 = (float)jarg2;
27109   {
27110     try {
27111       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2);
27112     } CALL_CATCH_EXCEPTION(0);
27113   }
27114
27115   jresult = (void *)result;
27116   return jresult;
27117 }
27118
27119
27120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimePeriod(void * jarg1) {
27121   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
27122
27123   arg1 = (Dali::TimePeriod *)jarg1;
27124   {
27125     try {
27126       delete arg1;
27127     } CALL_CATCH_EXCEPTION();
27128   }
27129
27130 }
27131
27132
27133 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) {
27134   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
27135   float arg2 ;
27136
27137   arg1 = (Dali::TimePeriod *)jarg1;
27138   arg2 = (float)jarg2;
27139   if (arg1) (arg1)->delaySeconds = arg2;
27140 }
27141
27142
27143 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_get(void * jarg1) {
27144   float jresult ;
27145   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
27146   float result;
27147
27148   arg1 = (Dali::TimePeriod *)jarg1;
27149   result = (float) ((arg1)->delaySeconds);
27150   jresult = result;
27151   return jresult;
27152 }
27153
27154
27155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) {
27156   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
27157   float arg2 ;
27158
27159   arg1 = (Dali::TimePeriod *)jarg1;
27160   arg2 = (float)jarg2;
27161   if (arg1) (arg1)->durationSeconds = arg2;
27162 }
27163
27164
27165 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_get(void * jarg1) {
27166   float jresult ;
27167   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
27168   float result;
27169
27170   arg1 = (Dali::TimePeriod *)jarg1;
27171   result = (float) ((arg1)->durationSeconds);
27172   jresult = result;
27173   return jresult;
27174 }
27175
27176 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_VALUE_get() {
27177   int jresult ;
27178   int result;
27179
27180   result = (int)Dali::LinearConstrainer::Property::VALUE;
27181   jresult = (int)result;
27182   return jresult;
27183 }
27184
27185
27186 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_PROGRESS_get() {
27187   int jresult ;
27188   int result;
27189
27190   result = (int)Dali::LinearConstrainer::Property::PROGRESS;
27191   jresult = (int)result;
27192   return jresult;
27193 }
27194
27195
27196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer_Property() {
27197   void * jresult ;
27198   Dali::LinearConstrainer::Property *result = 0 ;
27199
27200   {
27201     try {
27202       result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property();
27203     } CALL_CATCH_EXCEPTION(0);
27204   }
27205
27206   jresult = (void *)result;
27207   return jresult;
27208 }
27209
27210
27211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer_Property(void * jarg1) {
27212   Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ;
27213
27214   arg1 = (Dali::LinearConstrainer::Property *)jarg1;
27215   {
27216     try {
27217       delete arg1;
27218     } CALL_CATCH_EXCEPTION();
27219   }
27220
27221 }
27222
27223
27224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_New() {
27225   void * jresult ;
27226   Dali::LinearConstrainer result;
27227
27228   {
27229     try {
27230       result = Dali::LinearConstrainer::New();
27231     } CALL_CATCH_EXCEPTION(0);
27232   }
27233
27234   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
27235   return jresult;
27236 }
27237
27238
27239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_DownCast(void * jarg1) {
27240   void * jresult ;
27241   Dali::BaseHandle arg1 ;
27242   Dali::BaseHandle *argp1 ;
27243   Dali::LinearConstrainer result;
27244
27245   argp1 = (Dali::BaseHandle *)jarg1;
27246   if (!argp1) {
27247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27248     return 0;
27249   }
27250   arg1 = *argp1;
27251   {
27252     try {
27253       result = Dali::LinearConstrainer::DownCast(arg1);
27254     } CALL_CATCH_EXCEPTION(0);
27255   }
27256
27257   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
27258   return jresult;
27259 }
27260
27261
27262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_0() {
27263   void * jresult ;
27264   Dali::LinearConstrainer *result = 0 ;
27265
27266   {
27267     try {
27268       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer();
27269     } CALL_CATCH_EXCEPTION(0);
27270   }
27271
27272   jresult = (void *)result;
27273   return jresult;
27274 }
27275
27276
27277 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer(void * jarg1) {
27278   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
27279
27280   arg1 = (Dali::LinearConstrainer *)jarg1;
27281   {
27282     try {
27283       delete arg1;
27284     } CALL_CATCH_EXCEPTION();
27285   }
27286
27287 }
27288
27289
27290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_1(void * jarg1) {
27291   void * jresult ;
27292   Dali::LinearConstrainer *arg1 = 0 ;
27293   Dali::LinearConstrainer *result = 0 ;
27294
27295   arg1 = (Dali::LinearConstrainer *)jarg1;
27296   if (!arg1) {
27297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
27298     return 0;
27299   }
27300   {
27301     try {
27302       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1);
27303     } CALL_CATCH_EXCEPTION(0);
27304   }
27305
27306   jresult = (void *)result;
27307   return jresult;
27308 }
27309
27310
27311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_Assign(void * jarg1, void * jarg2) {
27312   void * jresult ;
27313   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
27314   Dali::LinearConstrainer *arg2 = 0 ;
27315   Dali::LinearConstrainer *result = 0 ;
27316
27317   arg1 = (Dali::LinearConstrainer *)jarg1;
27318   arg2 = (Dali::LinearConstrainer *)jarg2;
27319   if (!arg2) {
27320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
27321     return 0;
27322   }
27323   {
27324     try {
27325       result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2);
27326     } CALL_CATCH_EXCEPTION(0);
27327   }
27328
27329   jresult = (void *)result;
27330   return jresult;
27331 }
27332
27333
27334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
27335   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
27336   SwigValueWrapper< Dali::Property > arg2 ;
27337   SwigValueWrapper< Dali::Property > arg3 ;
27338   Dali::Vector2 *arg4 = 0 ;
27339   Dali::Vector2 *arg5 = 0 ;
27340   Dali::Property *argp2 ;
27341   Dali::Property *argp3 ;
27342
27343   arg1 = (Dali::LinearConstrainer *)jarg1;
27344   argp2 = (Dali::Property *)jarg2;
27345   if (!argp2) {
27346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
27347     return ;
27348   }
27349   arg2 = *argp2;
27350   argp3 = (Dali::Property *)jarg3;
27351   if (!argp3) {
27352     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
27353     return ;
27354   }
27355   arg3 = *argp3;
27356   arg4 = (Dali::Vector2 *)jarg4;
27357   if (!arg4) {
27358     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
27359     return ;
27360   }
27361   arg5 = (Dali::Vector2 *)jarg5;
27362   if (!arg5) {
27363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
27364     return ;
27365   }
27366   {
27367     try {
27368       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
27369     } CALL_CATCH_EXCEPTION();
27370   }
27371
27372 }
27373
27374
27375 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
27376   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
27377   SwigValueWrapper< Dali::Property > arg2 ;
27378   SwigValueWrapper< Dali::Property > arg3 ;
27379   Dali::Vector2 *arg4 = 0 ;
27380   Dali::Property *argp2 ;
27381   Dali::Property *argp3 ;
27382
27383   arg1 = (Dali::LinearConstrainer *)jarg1;
27384   argp2 = (Dali::Property *)jarg2;
27385   if (!argp2) {
27386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
27387     return ;
27388   }
27389   arg2 = *argp2;
27390   argp3 = (Dali::Property *)jarg3;
27391   if (!argp3) {
27392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
27393     return ;
27394   }
27395   arg3 = *argp3;
27396   arg4 = (Dali::Vector2 *)jarg4;
27397   if (!arg4) {
27398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
27399     return ;
27400   }
27401   {
27402     try {
27403       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
27404     } CALL_CATCH_EXCEPTION();
27405   }
27406
27407 }
27408
27409
27410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Remove(void * jarg1, void * jarg2) {
27411   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
27412   Dali::Handle *arg2 = 0 ;
27413
27414   arg1 = (Dali::LinearConstrainer *)jarg1;
27415   arg2 = (Dali::Handle *)jarg2;
27416   if (!arg2) {
27417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
27418     return ;
27419   }
27420   {
27421     try {
27422       (arg1)->Remove(*arg2);
27423     } CALL_CATCH_EXCEPTION();
27424   }
27425
27426 }
27427
27428
27429 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_FORWARD_get() {
27430   int jresult ;
27431   int result;
27432
27433   result = (int)Dali::PathConstrainer::Property::FORWARD;
27434   jresult = (int)result;
27435   return jresult;
27436 }
27437
27438
27439 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_POINTS_get() {
27440   int jresult ;
27441   int result;
27442
27443   result = (int)Dali::PathConstrainer::Property::POINTS;
27444   jresult = (int)result;
27445   return jresult;
27446 }
27447
27448
27449 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_CONTROL_POINTS_get() {
27450   int jresult ;
27451   int result;
27452
27453   result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS;
27454   jresult = (int)result;
27455   return jresult;
27456 }
27457
27458
27459 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer_Property() {
27460   void * jresult ;
27461   Dali::PathConstrainer::Property *result = 0 ;
27462
27463   {
27464     try {
27465       result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property();
27466     } CALL_CATCH_EXCEPTION(0);
27467   }
27468
27469   jresult = (void *)result;
27470   return jresult;
27471 }
27472
27473
27474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer_Property(void * jarg1) {
27475   Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ;
27476
27477   arg1 = (Dali::PathConstrainer::Property *)jarg1;
27478   {
27479     try {
27480       delete arg1;
27481     } CALL_CATCH_EXCEPTION();
27482   }
27483
27484 }
27485
27486
27487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_New() {
27488   void * jresult ;
27489   Dali::PathConstrainer result;
27490
27491   {
27492     try {
27493       result = Dali::PathConstrainer::New();
27494     } CALL_CATCH_EXCEPTION(0);
27495   }
27496
27497   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
27498   return jresult;
27499 }
27500
27501
27502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_DownCast(void * jarg1) {
27503   void * jresult ;
27504   Dali::BaseHandle arg1 ;
27505   Dali::BaseHandle *argp1 ;
27506   Dali::PathConstrainer result;
27507
27508   argp1 = (Dali::BaseHandle *)jarg1;
27509   if (!argp1) {
27510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27511     return 0;
27512   }
27513   arg1 = *argp1;
27514   {
27515     try {
27516       result = Dali::PathConstrainer::DownCast(arg1);
27517     } CALL_CATCH_EXCEPTION(0);
27518   }
27519
27520   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
27521   return jresult;
27522 }
27523
27524
27525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_0() {
27526   void * jresult ;
27527   Dali::PathConstrainer *result = 0 ;
27528
27529   {
27530     try {
27531       result = (Dali::PathConstrainer *)new Dali::PathConstrainer();
27532     } CALL_CATCH_EXCEPTION(0);
27533   }
27534
27535   jresult = (void *)result;
27536   return jresult;
27537 }
27538
27539
27540 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer(void * jarg1) {
27541   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
27542
27543   arg1 = (Dali::PathConstrainer *)jarg1;
27544   {
27545     try {
27546       delete arg1;
27547     } CALL_CATCH_EXCEPTION();
27548   }
27549
27550 }
27551
27552
27553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_1(void * jarg1) {
27554   void * jresult ;
27555   Dali::PathConstrainer *arg1 = 0 ;
27556   Dali::PathConstrainer *result = 0 ;
27557
27558   arg1 = (Dali::PathConstrainer *)jarg1;
27559   if (!arg1) {
27560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
27561     return 0;
27562   }
27563   {
27564     try {
27565       result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1);
27566     } CALL_CATCH_EXCEPTION(0);
27567   }
27568
27569   jresult = (void *)result;
27570   return jresult;
27571 }
27572
27573
27574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_Assign(void * jarg1, void * jarg2) {
27575   void * jresult ;
27576   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
27577   Dali::PathConstrainer *arg2 = 0 ;
27578   Dali::PathConstrainer *result = 0 ;
27579
27580   arg1 = (Dali::PathConstrainer *)jarg1;
27581   arg2 = (Dali::PathConstrainer *)jarg2;
27582   if (!arg2) {
27583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
27584     return 0;
27585   }
27586   {
27587     try {
27588       result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2);
27589     } CALL_CATCH_EXCEPTION(0);
27590   }
27591
27592   jresult = (void *)result;
27593   return jresult;
27594 }
27595
27596
27597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
27598   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
27599   SwigValueWrapper< Dali::Property > arg2 ;
27600   SwigValueWrapper< Dali::Property > arg3 ;
27601   Dali::Vector2 *arg4 = 0 ;
27602   Dali::Vector2 *arg5 = 0 ;
27603   Dali::Property *argp2 ;
27604   Dali::Property *argp3 ;
27605
27606   arg1 = (Dali::PathConstrainer *)jarg1;
27607   argp2 = (Dali::Property *)jarg2;
27608   if (!argp2) {
27609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
27610     return ;
27611   }
27612   arg2 = *argp2;
27613   argp3 = (Dali::Property *)jarg3;
27614   if (!argp3) {
27615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
27616     return ;
27617   }
27618   arg3 = *argp3;
27619   arg4 = (Dali::Vector2 *)jarg4;
27620   if (!arg4) {
27621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
27622     return ;
27623   }
27624   arg5 = (Dali::Vector2 *)jarg5;
27625   if (!arg5) {
27626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
27627     return ;
27628   }
27629   {
27630     try {
27631       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
27632     } CALL_CATCH_EXCEPTION();
27633   }
27634
27635 }
27636
27637
27638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
27639   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
27640   SwigValueWrapper< Dali::Property > arg2 ;
27641   SwigValueWrapper< Dali::Property > arg3 ;
27642   Dali::Vector2 *arg4 = 0 ;
27643   Dali::Property *argp2 ;
27644   Dali::Property *argp3 ;
27645
27646   arg1 = (Dali::PathConstrainer *)jarg1;
27647   argp2 = (Dali::Property *)jarg2;
27648   if (!argp2) {
27649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
27650     return ;
27651   }
27652   arg2 = *argp2;
27653   argp3 = (Dali::Property *)jarg3;
27654   if (!argp3) {
27655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
27656     return ;
27657   }
27658   arg3 = *argp3;
27659   arg4 = (Dali::Vector2 *)jarg4;
27660   if (!arg4) {
27661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
27662     return ;
27663   }
27664   {
27665     try {
27666       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
27667     } CALL_CATCH_EXCEPTION();
27668   }
27669
27670 }
27671
27672
27673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Remove(void * jarg1, void * jarg2) {
27674   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
27675   Dali::Handle *arg2 = 0 ;
27676
27677   arg1 = (Dali::PathConstrainer *)jarg1;
27678   arg2 = (Dali::Handle *)jarg2;
27679   if (!arg2) {
27680     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
27681     return ;
27682   }
27683   {
27684     try {
27685       (arg1)->Remove(*arg2);
27686     } CALL_CATCH_EXCEPTION();
27687   }
27688
27689 }
27690
27691
27692 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FittingModeDefault_get() {
27693   int jresult ;
27694   Dali::FittingMode::Type result;
27695
27696   result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT;
27697   jresult = (int)result;
27698   return jresult;
27699 }
27700
27701
27702 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DEFAULT_get() {
27703   int jresult ;
27704   Dali::SamplingMode::Type result;
27705
27706   result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT;
27707   jresult = (int)result;
27708   return jresult;
27709 }
27710
27711
27712 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_CreateResource(void * jarg1) {
27713   unsigned int jresult ;
27714   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
27715   bool result;
27716
27717   arg1 = (Dali::NativeImageInterface *)jarg1;
27718   {
27719     try {
27720       result = (bool)(arg1)->CreateResource();
27721     } CALL_CATCH_EXCEPTION(0);
27722   }
27723
27724   jresult = result;
27725   return jresult;
27726 }
27727
27728
27729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_DestroyResource(void * jarg1) {
27730   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
27731
27732   arg1 = (Dali::NativeImageInterface *)jarg1;
27733   {
27734     try {
27735       (arg1)->DestroyResource();
27736     } CALL_CATCH_EXCEPTION();
27737   }
27738
27739 }
27740
27741
27742 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_TargetTexture(void * jarg1) {
27743   unsigned int jresult ;
27744   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
27745   unsigned int result;
27746
27747   arg1 = (Dali::NativeImageInterface *)jarg1;
27748   {
27749     try {
27750       result = (unsigned int)(arg1)->TargetTexture();
27751     } CALL_CATCH_EXCEPTION(0);
27752   }
27753
27754   jresult = result;
27755   return jresult;
27756 }
27757
27758
27759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_PrepareTexture(void * jarg1) {
27760   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
27761
27762   arg1 = (Dali::NativeImageInterface *)jarg1;
27763   {
27764     try {
27765       (arg1)->PrepareTexture();
27766     } CALL_CATCH_EXCEPTION();
27767   }
27768
27769 }
27770
27771
27772 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetWidth(void * jarg1) {
27773   unsigned int jresult ;
27774   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
27775   unsigned int result;
27776
27777   arg1 = (Dali::NativeImageInterface *)jarg1;
27778   {
27779     try {
27780       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth();
27781     } CALL_CATCH_EXCEPTION(0);
27782   }
27783
27784   jresult = result;
27785   return jresult;
27786 }
27787
27788
27789 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetHeight(void * jarg1) {
27790   unsigned int jresult ;
27791   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
27792   unsigned int result;
27793
27794   arg1 = (Dali::NativeImageInterface *)jarg1;
27795   {
27796     try {
27797       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetHeight();
27798     } CALL_CATCH_EXCEPTION(0);
27799   }
27800
27801   jresult = result;
27802   return jresult;
27803 }
27804
27805
27806 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_RequiresBlending(void * jarg1) {
27807   unsigned int jresult ;
27808   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
27809   bool result;
27810
27811   arg1 = (Dali::NativeImageInterface *)jarg1;
27812   {
27813     try {
27814       result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending();
27815     } CALL_CATCH_EXCEPTION(0);
27816   }
27817
27818   jresult = result;
27819   return jresult;
27820 }
27821
27822 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TYPE_get() {
27823   int jresult ;
27824   int result;
27825
27826   result = (int)Dali::CameraActor::Property::TYPE;
27827   jresult = (int)result;
27828   return jresult;
27829 }
27830
27831
27832 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MODE_get() {
27833   int jresult ;
27834   int result;
27835
27836   result = (int)Dali::CameraActor::Property::PROJECTION_MODE;
27837   jresult = (int)result;
27838   return jresult;
27839 }
27840
27841
27842 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FIELD_OF_VIEW_get() {
27843   int jresult ;
27844   int result;
27845
27846   result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW;
27847   jresult = (int)result;
27848   return jresult;
27849 }
27850
27851
27852 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ASPECT_RATIO_get() {
27853   int jresult ;
27854   int result;
27855
27856   result = (int)Dali::CameraActor::Property::ASPECT_RATIO;
27857   jresult = (int)result;
27858   return jresult;
27859 }
27860
27861
27862 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_NEAR_PLANE_DISTANCE_get() {
27863   int jresult ;
27864   int result;
27865
27866   result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE;
27867   jresult = (int)result;
27868   return jresult;
27869 }
27870
27871
27872 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FAR_PLANE_DISTANCE_get() {
27873   int jresult ;
27874   int result;
27875
27876   result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE;
27877   jresult = (int)result;
27878   return jresult;
27879 }
27880
27881
27882 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_LEFT_PLANE_DISTANCE_get() {
27883   int jresult ;
27884   int result;
27885
27886   result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE;
27887   jresult = (int)result;
27888   return jresult;
27889 }
27890
27891
27892 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() {
27893   int jresult ;
27894   int result;
27895
27896   result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE;
27897   jresult = (int)result;
27898   return jresult;
27899 }
27900
27901
27902 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TOP_PLANE_DISTANCE_get() {
27903   int jresult ;
27904   int result;
27905
27906   result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE;
27907   jresult = (int)result;
27908   return jresult;
27909 }
27910
27911
27912 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() {
27913   int jresult ;
27914   int result;
27915
27916   result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE;
27917   jresult = (int)result;
27918   return jresult;
27919 }
27920
27921
27922 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TARGET_POSITION_get() {
27923   int jresult ;
27924   int result;
27925
27926   result = (int)Dali::CameraActor::Property::TARGET_POSITION;
27927   jresult = (int)result;
27928   return jresult;
27929 }
27930
27931
27932 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MATRIX_get() {
27933   int jresult ;
27934   int result;
27935
27936   result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX;
27937   jresult = (int)result;
27938   return jresult;
27939 }
27940
27941
27942 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_VIEW_MATRIX_get() {
27943   int jresult ;
27944   int result;
27945
27946   result = (int)Dali::CameraActor::Property::VIEW_MATRIX;
27947   jresult = (int)result;
27948   return jresult;
27949 }
27950
27951
27952 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_INVERT_Y_AXIS_get() {
27953   int jresult ;
27954   int result;
27955
27956   result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS;
27957   jresult = (int)result;
27958   return jresult;
27959 }
27960
27961
27962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor_Property() {
27963   void * jresult ;
27964   Dali::CameraActor::Property *result = 0 ;
27965
27966   {
27967     try {
27968       result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property();
27969     } CALL_CATCH_EXCEPTION(0);
27970   }
27971
27972   jresult = (void *)result;
27973   return jresult;
27974 }
27975
27976
27977 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor_Property(void * jarg1) {
27978   Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ;
27979
27980   arg1 = (Dali::CameraActor::Property *)jarg1;
27981   {
27982     try {
27983       delete arg1;
27984     } CALL_CATCH_EXCEPTION();
27985   }
27986
27987 }
27988
27989
27990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_0() {
27991   void * jresult ;
27992   Dali::CameraActor *result = 0 ;
27993
27994   {
27995     try {
27996       result = (Dali::CameraActor *)new Dali::CameraActor();
27997     } CALL_CATCH_EXCEPTION(0);
27998   }
27999
28000   jresult = (void *)result;
28001   return jresult;
28002 }
28003
28004
28005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_0() {
28006   void * jresult ;
28007   Dali::CameraActor result;
28008
28009   {
28010     try {
28011       result = Dali::CameraActor::New();
28012     } CALL_CATCH_EXCEPTION(0);
28013   }
28014
28015   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
28016   return jresult;
28017 }
28018
28019
28020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_1(void * jarg1) {
28021   void * jresult ;
28022   Dali::Size *arg1 = 0 ;
28023   Dali::CameraActor result;
28024
28025   arg1 = (Dali::Size *)jarg1;
28026   if (!arg1) {
28027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
28028     return 0;
28029   }
28030   {
28031     try {
28032       result = Dali::CameraActor::New((Dali::Vector2 const &)*arg1);
28033     } CALL_CATCH_EXCEPTION(0);
28034   }
28035
28036   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
28037   return jresult;
28038 }
28039
28040
28041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_DownCast(void * jarg1) {
28042   void * jresult ;
28043   Dali::BaseHandle arg1 ;
28044   Dali::BaseHandle *argp1 ;
28045   Dali::CameraActor result;
28046
28047   argp1 = (Dali::BaseHandle *)jarg1;
28048   if (!argp1) {
28049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
28050     return 0;
28051   }
28052   arg1 = *argp1;
28053   {
28054     try {
28055       result = Dali::CameraActor::DownCast(arg1);
28056     } CALL_CATCH_EXCEPTION(0);
28057   }
28058
28059   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
28060   return jresult;
28061 }
28062
28063
28064 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor(void * jarg1) {
28065   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28066
28067   arg1 = (Dali::CameraActor *)jarg1;
28068   {
28069     try {
28070       delete arg1;
28071     } CALL_CATCH_EXCEPTION();
28072   }
28073
28074 }
28075
28076
28077 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_1(void * jarg1) {
28078   void * jresult ;
28079   Dali::CameraActor *arg1 = 0 ;
28080   Dali::CameraActor *result = 0 ;
28081
28082   arg1 = (Dali::CameraActor *)jarg1;
28083   if (!arg1) {
28084     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
28085     return 0;
28086   }
28087   {
28088     try {
28089       result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1);
28090     } CALL_CATCH_EXCEPTION(0);
28091   }
28092
28093   jresult = (void *)result;
28094   return jresult;
28095 }
28096
28097
28098 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_Assign(void * jarg1, void * jarg2) {
28099   void * jresult ;
28100   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28101   Dali::CameraActor *arg2 = 0 ;
28102   Dali::CameraActor *result = 0 ;
28103
28104   arg1 = (Dali::CameraActor *)jarg1;
28105   arg2 = (Dali::CameraActor *)jarg2;
28106   if (!arg2) {
28107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
28108     return 0;
28109   }
28110   {
28111     try {
28112       result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2);
28113     } CALL_CATCH_EXCEPTION(0);
28114   }
28115
28116   jresult = (void *)result;
28117   return jresult;
28118 }
28119
28120
28121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetType(void * jarg1, int jarg2) {
28122   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28123   Dali::Camera::Type arg2 ;
28124
28125   arg1 = (Dali::CameraActor *)jarg1;
28126   arg2 = (Dali::Camera::Type)jarg2;
28127   {
28128     try {
28129       (arg1)->SetType(arg2);
28130     } CALL_CATCH_EXCEPTION();
28131   }
28132
28133 }
28134
28135
28136 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetType(void * jarg1) {
28137   int jresult ;
28138   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28139   Dali::Camera::Type result;
28140
28141   arg1 = (Dali::CameraActor *)jarg1;
28142   {
28143     try {
28144       result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType();
28145     } CALL_CATCH_EXCEPTION(0);
28146   }
28147
28148   jresult = (int)result;
28149   return jresult;
28150 }
28151
28152
28153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetProjectionMode(void * jarg1, int jarg2) {
28154   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28155   Dali::Camera::ProjectionMode arg2 ;
28156
28157   arg1 = (Dali::CameraActor *)jarg1;
28158   arg2 = (Dali::Camera::ProjectionMode)jarg2;
28159   {
28160     try {
28161       (arg1)->SetProjectionMode(arg2);
28162     } CALL_CATCH_EXCEPTION();
28163   }
28164
28165 }
28166
28167
28168 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetProjectionMode(void * jarg1) {
28169   int jresult ;
28170   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28171   Dali::Camera::ProjectionMode result;
28172
28173   arg1 = (Dali::CameraActor *)jarg1;
28174   {
28175     try {
28176       result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode();
28177     } CALL_CATCH_EXCEPTION(0);
28178   }
28179
28180   jresult = (int)result;
28181   return jresult;
28182 }
28183
28184
28185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFieldOfView(void * jarg1, float jarg2) {
28186   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28187   float arg2 ;
28188
28189   arg1 = (Dali::CameraActor *)jarg1;
28190   arg2 = (float)jarg2;
28191   {
28192     try {
28193       (arg1)->SetFieldOfView(arg2);
28194     } CALL_CATCH_EXCEPTION();
28195   }
28196
28197 }
28198
28199
28200 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFieldOfView(void * jarg1) {
28201   float jresult ;
28202   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28203   float result;
28204
28205   arg1 = (Dali::CameraActor *)jarg1;
28206   {
28207     try {
28208       result = (float)(arg1)->GetFieldOfView();
28209     } CALL_CATCH_EXCEPTION(0);
28210   }
28211
28212   jresult = result;
28213   return jresult;
28214 }
28215
28216
28217 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetAspectRatio(void * jarg1, float jarg2) {
28218   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28219   float arg2 ;
28220
28221   arg1 = (Dali::CameraActor *)jarg1;
28222   arg2 = (float)jarg2;
28223   {
28224     try {
28225       (arg1)->SetAspectRatio(arg2);
28226     } CALL_CATCH_EXCEPTION();
28227   }
28228
28229 }
28230
28231
28232 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetAspectRatio(void * jarg1) {
28233   float jresult ;
28234   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28235   float result;
28236
28237   arg1 = (Dali::CameraActor *)jarg1;
28238   {
28239     try {
28240       result = (float)(arg1)->GetAspectRatio();
28241     } CALL_CATCH_EXCEPTION(0);
28242   }
28243
28244   jresult = result;
28245   return jresult;
28246 }
28247
28248
28249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) {
28250   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28251   float arg2 ;
28252
28253   arg1 = (Dali::CameraActor *)jarg1;
28254   arg2 = (float)jarg2;
28255   {
28256     try {
28257       (arg1)->SetNearClippingPlane(arg2);
28258     } CALL_CATCH_EXCEPTION();
28259   }
28260
28261 }
28262
28263
28264 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetNearClippingPlane(void * jarg1) {
28265   float jresult ;
28266   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28267   float result;
28268
28269   arg1 = (Dali::CameraActor *)jarg1;
28270   {
28271     try {
28272       result = (float)(arg1)->GetNearClippingPlane();
28273     } CALL_CATCH_EXCEPTION(0);
28274   }
28275
28276   jresult = result;
28277   return jresult;
28278 }
28279
28280
28281 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) {
28282   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28283   float arg2 ;
28284
28285   arg1 = (Dali::CameraActor *)jarg1;
28286   arg2 = (float)jarg2;
28287   {
28288     try {
28289       (arg1)->SetFarClippingPlane(arg2);
28290     } CALL_CATCH_EXCEPTION();
28291   }
28292
28293 }
28294
28295
28296 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFarClippingPlane(void * jarg1) {
28297   float jresult ;
28298   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28299   float result;
28300
28301   arg1 = (Dali::CameraActor *)jarg1;
28302   {
28303     try {
28304       result = (float)(arg1)->GetFarClippingPlane();
28305     } CALL_CATCH_EXCEPTION(0);
28306   }
28307
28308   jresult = result;
28309   return jresult;
28310 }
28311
28312
28313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) {
28314   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28315   Dali::Vector3 *arg2 = 0 ;
28316
28317   arg1 = (Dali::CameraActor *)jarg1;
28318   arg2 = (Dali::Vector3 *)jarg2;
28319   if (!arg2) {
28320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
28321     return ;
28322   }
28323   {
28324     try {
28325       (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2);
28326     } CALL_CATCH_EXCEPTION();
28327   }
28328
28329 }
28330
28331
28332 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_GetTargetPosition(void * jarg1) {
28333   void * jresult ;
28334   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28335   Dali::Vector3 result;
28336
28337   arg1 = (Dali::CameraActor *)jarg1;
28338   {
28339     try {
28340       result = ((Dali::CameraActor const *)arg1)->GetTargetPosition();
28341     } CALL_CATCH_EXCEPTION(0);
28342   }
28343
28344   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
28345   return jresult;
28346 }
28347
28348
28349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetInvertYAxis(void * jarg1, unsigned int jarg2) {
28350   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28351   bool arg2 ;
28352
28353   arg1 = (Dali::CameraActor *)jarg1;
28354   arg2 = jarg2 ? true : false;
28355   {
28356     try {
28357       (arg1)->SetInvertYAxis(arg2);
28358     } CALL_CATCH_EXCEPTION();
28359   }
28360
28361 }
28362
28363
28364 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CameraActor_GetInvertYAxis(void * jarg1) {
28365   unsigned int jresult ;
28366   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28367   bool result;
28368
28369   arg1 = (Dali::CameraActor *)jarg1;
28370   {
28371     try {
28372       result = (bool)(arg1)->GetInvertYAxis();
28373     } CALL_CATCH_EXCEPTION(0);
28374   }
28375
28376   jresult = result;
28377   return jresult;
28378 }
28379
28380
28381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) {
28382   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28383   Dali::Size *arg2 = 0 ;
28384
28385   arg1 = (Dali::CameraActor *)jarg1;
28386   arg2 = (Dali::Size *)jarg2;
28387   if (!arg2) {
28388     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
28389     return ;
28390   }
28391   {
28392     try {
28393       (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2);
28394     } CALL_CATCH_EXCEPTION();
28395   }
28396
28397 }
28398
28399
28400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) {
28401   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28402   Dali::Size *arg2 = 0 ;
28403
28404   arg1 = (Dali::CameraActor *)jarg1;
28405   arg2 = (Dali::Size *)jarg2;
28406   if (!arg2) {
28407     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
28408     return ;
28409   }
28410   {
28411     try {
28412       (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2);
28413     } CALL_CATCH_EXCEPTION();
28414   }
28415
28416 }
28417
28418
28419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7) {
28420   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28421   float arg2 ;
28422   float arg3 ;
28423   float arg4 ;
28424   float arg5 ;
28425   float arg6 ;
28426   float arg7 ;
28427
28428   arg1 = (Dali::CameraActor *)jarg1;
28429   arg2 = (float)jarg2;
28430   arg3 = (float)jarg3;
28431   arg4 = (float)jarg4;
28432   arg5 = (float)jarg5;
28433   arg6 = (float)jarg6;
28434   arg7 = (float)jarg7;
28435   {
28436     try {
28437       (arg1)->SetOrthographicProjection(arg2,arg3,arg4,arg5,arg6,arg7);
28438     } CALL_CATCH_EXCEPTION();
28439   }
28440
28441 }
28442
28443
28444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_0() {
28445   void * jresult ;
28446   std::pair< std::string,Dali::Property::Value > *result = 0 ;
28447
28448   {
28449     try {
28450       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >();
28451     } CALL_CATCH_EXCEPTION(0);
28452   }
28453
28454   jresult = (void *)result;
28455   return jresult;
28456 }
28457
28458
28459 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) {
28460   void * jresult ;
28461   std::string arg1 ;
28462   Dali::Property::Value arg2 ;
28463   Dali::Property::Value *argp2 ;
28464   std::pair< std::string,Dali::Property::Value > *result = 0 ;
28465
28466   if (!jarg1) {
28467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
28468     return 0;
28469   }
28470   (&arg1)->assign(jarg1);
28471   argp2 = (Dali::Property::Value *)jarg2;
28472   if (!argp2) {
28473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
28474     return 0;
28475   }
28476   arg2 = *argp2;
28477   {
28478     try {
28479       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2);
28480     } CALL_CATCH_EXCEPTION(0);
28481   }
28482
28483   jresult = (void *)result;
28484   return jresult;
28485 }
28486
28487
28488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_2(void * jarg1) {
28489   void * jresult ;
28490   std::pair< std::string,Dali::Property::Value > *arg1 = 0 ;
28491   std::pair< std::string,Dali::Property::Value > *result = 0 ;
28492
28493   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
28494   if (!arg1) {
28495     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0);
28496     return 0;
28497   }
28498   {
28499     try {
28500       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);
28501     } CALL_CATCH_EXCEPTION(0);
28502   }
28503
28504   jresult = (void *)result;
28505   return jresult;
28506 }
28507
28508
28509 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_first_set(void * jarg1, char * jarg2) {
28510   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
28511   std::string *arg2 = 0 ;
28512
28513   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
28514   if (!jarg2) {
28515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
28516     return ;
28517   }
28518   std::string arg2_str(jarg2);
28519   arg2 = &arg2_str;
28520   if (arg1) (arg1)->first = *arg2;
28521
28522   //argout typemap for const std::string&
28523
28524 }
28525
28526
28527 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StringValuePair_first_get(void * jarg1) {
28528   char * jresult ;
28529   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
28530   std::string *result = 0 ;
28531
28532   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
28533   result = (std::string *) & ((arg1)->first);
28534   jresult = SWIG_csharp_string_callback(result->c_str());
28535   return jresult;
28536 }
28537
28538
28539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_second_set(void * jarg1, void * jarg2) {
28540   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
28541   Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ;
28542
28543   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
28544   arg2 = (Dali::Property::Value *)jarg2;
28545   if (arg1) (arg1)->second = *arg2;
28546 }
28547
28548
28549 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StringValuePair_second_get(void * jarg1) {
28550   void * jresult ;
28551   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
28552   Dali::Property::Value *result = 0 ;
28553
28554   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
28555   result = (Dali::Property::Value *)& ((arg1)->second);
28556   jresult = (void *)result;
28557   return jresult;
28558 }
28559
28560
28561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StringValuePair(void * jarg1) {
28562   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
28563
28564   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
28565   {
28566     try {
28567       delete arg1;
28568     } CALL_CATCH_EXCEPTION();
28569   }
28570
28571 }
28572
28573
28574 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Clear(void * jarg1) {
28575   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28576
28577   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28578   {
28579     try {
28580       (arg1)->clear();
28581     } CALL_CATCH_EXCEPTION();
28582   }
28583
28584 }
28585
28586
28587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Add(void * jarg1, void * jarg2) {
28588   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28589   Dali::TouchPoint *arg2 = 0 ;
28590
28591   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28592   arg2 = (Dali::TouchPoint *)jarg2;
28593   if (!arg2) {
28594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
28595     return ;
28596   }
28597   {
28598     try {
28599       (arg1)->push_back((Dali::TouchPoint const &)*arg2);
28600     } CALL_CATCH_EXCEPTION();
28601   }
28602
28603 }
28604
28605
28606 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_size(void * jarg1) {
28607   unsigned long jresult ;
28608   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28609   std::vector< Dali::TouchPoint >::size_type result;
28610
28611   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28612   {
28613     try {
28614       result = ((std::vector< Dali::TouchPoint > const *)arg1)->size();
28615     } CALL_CATCH_EXCEPTION(0);
28616   }
28617
28618   jresult = (unsigned long)result;
28619   return jresult;
28620 }
28621
28622
28623 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_capacity(void * jarg1) {
28624   unsigned long jresult ;
28625   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28626   std::vector< Dali::TouchPoint >::size_type result;
28627
28628   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28629   {
28630     try {
28631       result = ((std::vector< Dali::TouchPoint > const *)arg1)->capacity();
28632     } CALL_CATCH_EXCEPTION(0);
28633   }
28634
28635   jresult = (unsigned long)result;
28636   return jresult;
28637 }
28638
28639
28640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) {
28641   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28642   std::vector< Dali::TouchPoint >::size_type arg2 ;
28643
28644   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28645   arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2;
28646   {
28647     try {
28648       (arg1)->reserve(arg2);
28649     } CALL_CATCH_EXCEPTION();
28650   }
28651
28652 }
28653
28654
28655 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_0() {
28656   void * jresult ;
28657   std::vector< Dali::TouchPoint > *result = 0 ;
28658
28659   {
28660     try {
28661       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >();
28662     } CALL_CATCH_EXCEPTION(0);
28663   }
28664
28665   jresult = (void *)result;
28666   return jresult;
28667 }
28668
28669
28670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_1(void * jarg1) {
28671   void * jresult ;
28672   std::vector< Dali::TouchPoint > *arg1 = 0 ;
28673   std::vector< Dali::TouchPoint > *result = 0 ;
28674
28675   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28676   if (!arg1) {
28677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
28678     return 0;
28679   }
28680   {
28681     try {
28682       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1);
28683     } CALL_CATCH_EXCEPTION(0);
28684   }
28685
28686   jresult = (void *)result;
28687   return jresult;
28688 }
28689
28690
28691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_2(int jarg1) {
28692   void * jresult ;
28693   int arg1 ;
28694   std::vector< Dali::TouchPoint > *result = 0 ;
28695
28696   arg1 = (int)jarg1;
28697   {
28698     try {
28699       try {
28700         result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1);
28701       }
28702       catch(std::out_of_range &_e) {
28703         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
28704         return 0;
28705       }
28706
28707     } CALL_CATCH_EXCEPTION(0);
28708   }
28709
28710   jresult = (void *)result;
28711   return jresult;
28712 }
28713
28714
28715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) {
28716   void * jresult ;
28717   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28718   int arg2 ;
28719   SwigValueWrapper< Dali::TouchPoint > result;
28720
28721   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28722   arg2 = (int)jarg2;
28723   {
28724     try {
28725       try {
28726         result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2);
28727       }
28728       catch(std::out_of_range &_e) {
28729         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
28730         return 0;
28731       }
28732
28733     } CALL_CATCH_EXCEPTION(0);
28734   }
28735
28736   jresult = new Dali::TouchPoint((const Dali::TouchPoint &)result);
28737   return jresult;
28738 }
28739
28740
28741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitem(void * jarg1, int jarg2) {
28742   void * jresult ;
28743   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28744   int arg2 ;
28745   Dali::TouchPoint *result = 0 ;
28746
28747   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28748   arg2 = (int)jarg2;
28749   {
28750     try {
28751       try {
28752         result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2);
28753       }
28754       catch(std::out_of_range &_e) {
28755         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
28756         return 0;
28757       }
28758
28759     } CALL_CATCH_EXCEPTION(0);
28760   }
28761
28762   jresult = (void *)result;
28763   return jresult;
28764 }
28765
28766
28767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
28768   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28769   int arg2 ;
28770   Dali::TouchPoint *arg3 = 0 ;
28771
28772   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28773   arg2 = (int)jarg2;
28774   arg3 = (Dali::TouchPoint *)jarg3;
28775   if (!arg3) {
28776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
28777     return ;
28778   }
28779   {
28780     try {
28781       try {
28782         std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3);
28783       }
28784       catch(std::out_of_range &_e) {
28785         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
28786         return ;
28787       }
28788
28789     } CALL_CATCH_EXCEPTION();
28790   }
28791
28792 }
28793
28794
28795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_AddRange(void * jarg1, void * jarg2) {
28796   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28797   std::vector< Dali::TouchPoint > *arg2 = 0 ;
28798
28799   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28800   arg2 = (std::vector< Dali::TouchPoint > *)jarg2;
28801   if (!arg2) {
28802     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
28803     return ;
28804   }
28805   {
28806     try {
28807       std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2);
28808     } CALL_CATCH_EXCEPTION();
28809   }
28810
28811 }
28812
28813
28814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
28815   void * jresult ;
28816   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28817   int arg2 ;
28818   int arg3 ;
28819   std::vector< Dali::TouchPoint > *result = 0 ;
28820
28821   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28822   arg2 = (int)jarg2;
28823   arg3 = (int)jarg3;
28824   {
28825     try {
28826       try {
28827         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3);
28828       }
28829       catch(std::out_of_range &_e) {
28830         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
28831         return 0;
28832       }
28833       catch(std::invalid_argument &_e) {
28834         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
28835         return 0;
28836       }
28837
28838     } CALL_CATCH_EXCEPTION(0);
28839   }
28840
28841   jresult = (void *)result;
28842   return jresult;
28843 }
28844
28845
28846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
28847   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28848   int arg2 ;
28849   Dali::TouchPoint *arg3 = 0 ;
28850
28851   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28852   arg2 = (int)jarg2;
28853   arg3 = (Dali::TouchPoint *)jarg3;
28854   if (!arg3) {
28855     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
28856     return ;
28857   }
28858   {
28859     try {
28860       try {
28861         std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3);
28862       }
28863       catch(std::out_of_range &_e) {
28864         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
28865         return ;
28866       }
28867
28868     } CALL_CATCH_EXCEPTION();
28869   }
28870
28871 }
28872
28873
28874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
28875   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28876   int arg2 ;
28877   std::vector< Dali::TouchPoint > *arg3 = 0 ;
28878
28879   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28880   arg2 = (int)jarg2;
28881   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
28882   if (!arg3) {
28883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
28884     return ;
28885   }
28886   {
28887     try {
28888       try {
28889         std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
28890       }
28891       catch(std::out_of_range &_e) {
28892         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
28893         return ;
28894       }
28895
28896     } CALL_CATCH_EXCEPTION();
28897   }
28898
28899 }
28900
28901
28902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveAt(void * jarg1, int jarg2) {
28903   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28904   int arg2 ;
28905
28906   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28907   arg2 = (int)jarg2;
28908   {
28909     try {
28910       try {
28911         std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2);
28912       }
28913       catch(std::out_of_range &_e) {
28914         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
28915         return ;
28916       }
28917
28918     } CALL_CATCH_EXCEPTION();
28919   }
28920
28921 }
28922
28923
28924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
28925   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28926   int arg2 ;
28927   int arg3 ;
28928
28929   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28930   arg2 = (int)jarg2;
28931   arg3 = (int)jarg3;
28932   {
28933     try {
28934       try {
28935         std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3);
28936       }
28937       catch(std::out_of_range &_e) {
28938         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
28939         return ;
28940       }
28941       catch(std::invalid_argument &_e) {
28942         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
28943         return ;
28944       }
28945
28946     } CALL_CATCH_EXCEPTION();
28947   }
28948
28949 }
28950
28951
28952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_Repeat(void * jarg1, int jarg2) {
28953   void * jresult ;
28954   Dali::TouchPoint *arg1 = 0 ;
28955   int arg2 ;
28956   std::vector< Dali::TouchPoint > *result = 0 ;
28957
28958   arg1 = (Dali::TouchPoint *)jarg1;
28959   if (!arg1) {
28960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
28961     return 0;
28962   }
28963   arg2 = (int)jarg2;
28964   {
28965     try {
28966       try {
28967         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2);
28968       }
28969       catch(std::out_of_range &_e) {
28970         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
28971         return 0;
28972       }
28973
28974     } CALL_CATCH_EXCEPTION(0);
28975   }
28976
28977   jresult = (void *)result;
28978   return jresult;
28979 }
28980
28981
28982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_0(void * jarg1) {
28983   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28984
28985   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28986   {
28987     try {
28988       std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1);
28989     } CALL_CATCH_EXCEPTION();
28990   }
28991
28992 }
28993
28994
28995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
28996   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28997   int arg2 ;
28998   int arg3 ;
28999
29000   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
29001   arg2 = (int)jarg2;
29002   arg3 = (int)jarg3;
29003   {
29004     try {
29005       try {
29006         std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
29007       }
29008       catch(std::out_of_range &_e) {
29009         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
29010         return ;
29011       }
29012       catch(std::invalid_argument &_e) {
29013         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
29014         return ;
29015       }
29016
29017     } CALL_CATCH_EXCEPTION();
29018   }
29019
29020 }
29021
29022
29023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
29024   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
29025   int arg2 ;
29026   std::vector< Dali::TouchPoint > *arg3 = 0 ;
29027
29028   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
29029   arg2 = (int)jarg2;
29030   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
29031   if (!arg3) {
29032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
29033     return ;
29034   }
29035   {
29036     try {
29037       try {
29038         std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
29039       }
29040       catch(std::out_of_range &_e) {
29041         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
29042         return ;
29043       }
29044
29045     } CALL_CATCH_EXCEPTION();
29046   }
29047
29048 }
29049
29050
29051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPointContainer(void * jarg1) {
29052   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
29053
29054   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
29055   {
29056     try {
29057       delete arg1;
29058     } CALL_CATCH_EXCEPTION();
29059   }
29060
29061 }
29062
29063
29064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_0() {
29065   void * jresult ;
29066   Dali::Rect< int > *result = 0 ;
29067
29068   {
29069     try {
29070       result = (Dali::Rect< int > *)new Dali::Rect< int >();
29071     } CALL_CATCH_EXCEPTION(0);
29072   }
29073
29074   jresult = (void *)result;
29075   return jresult;
29076 }
29077
29078
29079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) {
29080   void * jresult ;
29081   int arg1 ;
29082   int arg2 ;
29083   int arg3 ;
29084   int arg4 ;
29085   Dali::Rect< int > *result = 0 ;
29086
29087   arg1 = (int)jarg1;
29088   arg2 = (int)jarg2;
29089   arg3 = (int)jarg3;
29090   arg4 = (int)jarg4;
29091   {
29092     try {
29093       result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4);
29094     } CALL_CATCH_EXCEPTION(0);
29095   }
29096
29097   jresult = (void *)result;
29098   return jresult;
29099 }
29100
29101
29102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_2(void * jarg1) {
29103   void * jresult ;
29104   Dali::Rect< int > *arg1 = 0 ;
29105   Dali::Rect< int > *result = 0 ;
29106
29107   arg1 = (Dali::Rect< int > *)jarg1;
29108   if (!arg1) {
29109     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
29110     return 0;
29111   }
29112   {
29113     try {
29114       result = (Dali::Rect< int > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1);
29115     } CALL_CATCH_EXCEPTION(0);
29116   }
29117
29118   jresult = (void *)result;
29119   return jresult;
29120 }
29121
29122
29123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rectangle_Assign(void * jarg1, void * jarg2) {
29124   void * jresult ;
29125   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29126   Dali::Rect< int > *arg2 = 0 ;
29127   Dali::Rect< int > *result = 0 ;
29128
29129   arg1 = (Dali::Rect< int > *)jarg1;
29130   arg2 = (Dali::Rect< int > *)jarg2;
29131   if (!arg2) {
29132     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
29133     return 0;
29134   }
29135   {
29136     try {
29137       result = (Dali::Rect< int > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2);
29138     } CALL_CATCH_EXCEPTION(0);
29139   }
29140
29141   jresult = (void *)result;
29142   return jresult;
29143 }
29144
29145
29146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
29147   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29148   int arg2 ;
29149   int arg3 ;
29150   int arg4 ;
29151   int arg5 ;
29152
29153   arg1 = (Dali::Rect< int > *)jarg1;
29154   arg2 = (int)jarg2;
29155   arg3 = (int)jarg3;
29156   arg4 = (int)jarg4;
29157   arg5 = (int)jarg5;
29158   {
29159     try {
29160       (arg1)->Set(arg2,arg3,arg4,arg5);
29161     } CALL_CATCH_EXCEPTION();
29162   }
29163
29164 }
29165
29166
29167 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_IsEmpty(void * jarg1) {
29168   unsigned int jresult ;
29169   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29170   bool result;
29171
29172   arg1 = (Dali::Rect< int > *)jarg1;
29173   {
29174     try {
29175       result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty();
29176     } CALL_CATCH_EXCEPTION(0);
29177   }
29178
29179   jresult = result;
29180   return jresult;
29181 }
29182
29183
29184 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Left(void * jarg1) {
29185   int jresult ;
29186   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29187   int result;
29188
29189   arg1 = (Dali::Rect< int > *)jarg1;
29190   {
29191     try {
29192       result = (int)((Dali::Rect< int > const *)arg1)->Left();
29193     } CALL_CATCH_EXCEPTION(0);
29194   }
29195
29196   jresult = result;
29197   return jresult;
29198 }
29199
29200
29201 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Right(void * jarg1) {
29202   int jresult ;
29203   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29204   int result;
29205
29206   arg1 = (Dali::Rect< int > *)jarg1;
29207   {
29208     try {
29209       result = (int)((Dali::Rect< int > const *)arg1)->Right();
29210     } CALL_CATCH_EXCEPTION(0);
29211   }
29212
29213   jresult = result;
29214   return jresult;
29215 }
29216
29217
29218 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Top(void * jarg1) {
29219   int jresult ;
29220   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29221   int result;
29222
29223   arg1 = (Dali::Rect< int > *)jarg1;
29224   {
29225     try {
29226       result = (int)((Dali::Rect< int > const *)arg1)->Top();
29227     } CALL_CATCH_EXCEPTION(0);
29228   }
29229
29230   jresult = result;
29231   return jresult;
29232 }
29233
29234
29235 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Bottom(void * jarg1) {
29236   int jresult ;
29237   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29238   int result;
29239
29240   arg1 = (Dali::Rect< int > *)jarg1;
29241   {
29242     try {
29243       result = (int)((Dali::Rect< int > const *)arg1)->Bottom();
29244     } CALL_CATCH_EXCEPTION(0);
29245   }
29246
29247   jresult = result;
29248   return jresult;
29249 }
29250
29251
29252 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Area(void * jarg1) {
29253   int jresult ;
29254   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29255   int result;
29256
29257   arg1 = (Dali::Rect< int > *)jarg1;
29258   {
29259     try {
29260       result = (int)((Dali::Rect< int > const *)arg1)->Area();
29261     } CALL_CATCH_EXCEPTION(0);
29262   }
29263
29264   jresult = result;
29265   return jresult;
29266 }
29267
29268
29269 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Intersects(void * jarg1, void * jarg2) {
29270   unsigned int jresult ;
29271   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29272   Dali::Rect< int > *arg2 = 0 ;
29273   bool result;
29274
29275   arg1 = (Dali::Rect< int > *)jarg1;
29276   arg2 = (Dali::Rect< int > *)jarg2;
29277   if (!arg2) {
29278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
29279     return 0;
29280   }
29281   {
29282     try {
29283       result = (bool)((Dali::Rect< int > const *)arg1)->Intersects((Dali::Rect< int > const &)*arg2);
29284     } CALL_CATCH_EXCEPTION(0);
29285   }
29286
29287   jresult = result;
29288   return jresult;
29289 }
29290
29291
29292 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Contains(void * jarg1, void * jarg2) {
29293   unsigned int jresult ;
29294   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29295   Dali::Rect< int > *arg2 = 0 ;
29296   bool result;
29297
29298   arg1 = (Dali::Rect< int > *)jarg1;
29299   arg2 = (Dali::Rect< int > *)jarg2;
29300   if (!arg2) {
29301     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
29302     return 0;
29303   }
29304   {
29305     try {
29306       result = (bool)((Dali::Rect< int > const *)arg1)->Contains((Dali::Rect< int > const &)*arg2);
29307     } CALL_CATCH_EXCEPTION(0);
29308   }
29309
29310   jresult = result;
29311   return jresult;
29312 }
29313
29314
29315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_x_set(void * jarg1, int jarg2) {
29316   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29317   int arg2 ;
29318
29319   arg1 = (Dali::Rect< int > *)jarg1;
29320   arg2 = (int)jarg2;
29321   if (arg1) (arg1)->x = arg2;
29322 }
29323
29324
29325 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_x_get(void * jarg1) {
29326   int jresult ;
29327   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29328   int result;
29329
29330   arg1 = (Dali::Rect< int > *)jarg1;
29331   result = (int) ((arg1)->x);
29332   jresult = result;
29333   return jresult;
29334 }
29335
29336
29337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_left_set(void * jarg1, int jarg2) {
29338   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29339   int arg2 ;
29340
29341   arg1 = (Dali::Rect< int > *)jarg1;
29342   arg2 = (int)jarg2;
29343   if (arg1) (arg1)->left = arg2;
29344 }
29345
29346
29347 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_left_get(void * jarg1) {
29348   int jresult ;
29349   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29350   int result;
29351
29352   arg1 = (Dali::Rect< int > *)jarg1;
29353   result = (int) ((arg1)->left);
29354   jresult = result;
29355   return jresult;
29356 }
29357
29358
29359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_y_set(void * jarg1, int jarg2) {
29360   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29361   int arg2 ;
29362
29363   arg1 = (Dali::Rect< int > *)jarg1;
29364   arg2 = (int)jarg2;
29365   if (arg1) (arg1)->y = arg2;
29366 }
29367
29368
29369 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_y_get(void * jarg1) {
29370   int jresult ;
29371   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29372   int result;
29373
29374   arg1 = (Dali::Rect< int > *)jarg1;
29375   result = (int) ((arg1)->y);
29376   jresult = result;
29377   return jresult;
29378 }
29379
29380
29381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_right_set(void * jarg1, int jarg2) {
29382   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29383   int arg2 ;
29384
29385   arg1 = (Dali::Rect< int > *)jarg1;
29386   arg2 = (int)jarg2;
29387   if (arg1) (arg1)->right = arg2;
29388 }
29389
29390
29391 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_right_get(void * jarg1) {
29392   int jresult ;
29393   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29394   int result;
29395
29396   arg1 = (Dali::Rect< int > *)jarg1;
29397   result = (int) ((arg1)->right);
29398   jresult = result;
29399   return jresult;
29400 }
29401
29402
29403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_width_set(void * jarg1, int jarg2) {
29404   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29405   int arg2 ;
29406
29407   arg1 = (Dali::Rect< int > *)jarg1;
29408   arg2 = (int)jarg2;
29409   if (arg1) (arg1)->width = arg2;
29410 }
29411
29412
29413 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_width_get(void * jarg1) {
29414   int jresult ;
29415   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29416   int result;
29417
29418   arg1 = (Dali::Rect< int > *)jarg1;
29419   result = (int) ((arg1)->width);
29420   jresult = result;
29421   return jresult;
29422 }
29423
29424
29425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_bottom_set(void * jarg1, int jarg2) {
29426   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29427   int arg2 ;
29428
29429   arg1 = (Dali::Rect< int > *)jarg1;
29430   arg2 = (int)jarg2;
29431   if (arg1) (arg1)->bottom = arg2;
29432 }
29433
29434
29435 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_bottom_get(void * jarg1) {
29436   int jresult ;
29437   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29438   int result;
29439
29440   arg1 = (Dali::Rect< int > *)jarg1;
29441   result = (int) ((arg1)->bottom);
29442   jresult = result;
29443   return jresult;
29444 }
29445
29446
29447 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_height_set(void * jarg1, int jarg2) {
29448   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29449   int arg2 ;
29450
29451   arg1 = (Dali::Rect< int > *)jarg1;
29452   arg2 = (int)jarg2;
29453   if (arg1) (arg1)->height = arg2;
29454 }
29455
29456
29457 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_height_get(void * jarg1) {
29458   int jresult ;
29459   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29460   int result;
29461
29462   arg1 = (Dali::Rect< int > *)jarg1;
29463   result = (int) ((arg1)->height);
29464   jresult = result;
29465   return jresult;
29466 }
29467
29468
29469 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_top_set(void * jarg1, int jarg2) {
29470   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29471   int arg2 ;
29472
29473   arg1 = (Dali::Rect< int > *)jarg1;
29474   arg2 = (int)jarg2;
29475   if (arg1) (arg1)->top = arg2;
29476 }
29477
29478
29479 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_top_get(void * jarg1) {
29480   int jresult ;
29481   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29482   int result;
29483
29484   arg1 = (Dali::Rect< int > *)jarg1;
29485   result = (int) ((arg1)->top);
29486   jresult = result;
29487   return jresult;
29488 }
29489
29490
29491 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rectangle(void * jarg1) {
29492   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29493
29494   arg1 = (Dali::Rect< int > *)jarg1;
29495   {
29496     try {
29497       delete arg1;
29498     } CALL_CATCH_EXCEPTION();
29499   }
29500
29501 }
29502
29503
29504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_0() {
29505   void * jresult ;
29506   Dali::Rect< float > *result = 0 ;
29507
29508   {
29509     try {
29510       result = (Dali::Rect< float > *)new Dali::Rect< float >();
29511     } CALL_CATCH_EXCEPTION(0);
29512   }
29513
29514   jresult = (void *)result;
29515   return jresult;
29516 }
29517
29518
29519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
29520   void * jresult ;
29521   float arg1 ;
29522   float arg2 ;
29523   float arg3 ;
29524   float arg4 ;
29525   Dali::Rect< float > *result = 0 ;
29526
29527   arg1 = (float)jarg1;
29528   arg2 = (float)jarg2;
29529   arg3 = (float)jarg4;
29530   arg4 = (float)jarg3;
29531   {
29532     try {
29533       result = (Dali::Rect< float > *)new Dali::Rect< float >(arg1,arg2,arg3,arg4);
29534     } CALL_CATCH_EXCEPTION(0);
29535   }
29536
29537   jresult = (void *)result;
29538   return jresult;
29539 }
29540
29541
29542 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_2(void * jarg1) {
29543   void * jresult ;
29544   Dali::Rect< float > *arg1 = 0 ;
29545   Dali::Rect< float > *result = 0 ;
29546
29547   arg1 = (Dali::Rect< float > *)jarg1;
29548   if (!arg1) {
29549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
29550     return 0;
29551   }
29552   {
29553     try {
29554       result = (Dali::Rect< float > *)new Dali::Rect< float >((Dali::Rect< float > const &)*arg1);
29555     } CALL_CATCH_EXCEPTION(0);
29556   }
29557
29558   jresult = (void *)result;
29559   return jresult;
29560 }
29561
29562
29563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PaddingType_Assign(void * jarg1, void * jarg2) {
29564   void * jresult ;
29565   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
29566   Dali::Rect< float > *arg2 = 0 ;
29567   Dali::Rect< float > *result = 0 ;
29568
29569   arg1 = (Dali::Rect< float > *)jarg1;
29570   arg2 = (Dali::Rect< float > *)jarg2;
29571   if (!arg2) {
29572     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
29573     return 0;
29574   }
29575   {
29576     try {
29577       result = (Dali::Rect< float > *) &(arg1)->operator =((Dali::Rect< float > const &)*arg2);
29578     } CALL_CATCH_EXCEPTION(0);
29579   }
29580
29581   jresult = (void *)result;
29582   return jresult;
29583 }
29584
29585
29586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_Set(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
29587   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
29588   float arg2 ;
29589   float arg3 ;
29590   float arg4 ;
29591   float arg5 ;
29592
29593   arg1 = (Dali::Rect< float > *)jarg1;
29594   arg2 = (float)jarg2;
29595   arg3 = (float)jarg3;
29596   arg4 = (float)jarg5;
29597   arg5 = (float)jarg4;
29598   {
29599     try {
29600       (arg1)->Set(arg2,arg3,arg4,arg5);
29601     } CALL_CATCH_EXCEPTION();
29602   }
29603
29604 }
29605
29606
29607 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_left_set(void * jarg1, float jarg2) {
29608   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
29609   float arg2 ;
29610
29611   arg1 = (Dali::Rect< float > *)jarg1;
29612   arg2 = (float)jarg2;
29613   if (arg1) (arg1)->left = arg2;
29614 }
29615
29616
29617 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_left_get(void * jarg1) {
29618   float jresult ;
29619   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
29620   float result;
29621
29622   arg1 = (Dali::Rect< float > *)jarg1;
29623   result = (float) ((arg1)->left);
29624   jresult = result;
29625   return jresult;
29626 }
29627
29628
29629 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_start_set(void * jarg1, float jarg2) {
29630   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
29631   float arg2 ;
29632
29633   arg1 = (Dali::Rect< float > *)jarg1;
29634   arg2 = (float)jarg2;
29635   if (arg1) (arg1)->left = arg2;
29636 }
29637
29638
29639 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_start_get(void * jarg1) {
29640   float jresult ;
29641   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
29642   float result;
29643
29644   arg1 = (Dali::Rect< float > *)jarg1;
29645   result = (float) ((arg1)->left);
29646   jresult = result;
29647   return jresult;
29648 }
29649
29650
29651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_right_set(void * jarg1, float jarg2) {
29652   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
29653   float arg2 ;
29654
29655   arg1 = (Dali::Rect< float > *)jarg1;
29656   arg2 = (float)jarg2;
29657   if (arg1) (arg1)->right = arg2;
29658 }
29659
29660
29661 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_right_get(void * jarg1) {
29662   float jresult ;
29663   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
29664   float result;
29665
29666   arg1 = (Dali::Rect< float > *)jarg1;
29667   result = (float) ((arg1)->right);
29668   jresult = result;
29669   return jresult;
29670 }
29671
29672
29673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_end_set(void * jarg1, float jarg2) {
29674   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
29675   float arg2 ;
29676
29677   arg1 = (Dali::Rect< float > *)jarg1;
29678   arg2 = (float)jarg2;
29679   if (arg1) (arg1)->right = arg2;
29680 }
29681
29682
29683 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_end_get(void * jarg1) {
29684   float jresult ;
29685   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
29686   float result;
29687
29688   arg1 = (Dali::Rect< float > *)jarg1;
29689   result = (float) ((arg1)->right);
29690   jresult = result;
29691   return jresult;
29692 }
29693
29694
29695 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_bottom_set(void * jarg1, float jarg2) {
29696   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
29697   float arg2 ;
29698
29699   arg1 = (Dali::Rect< float > *)jarg1;
29700   arg2 = (float)jarg2;
29701   if (arg1) (arg1)->bottom = arg2;
29702 }
29703
29704
29705 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_bottom_get(void * jarg1) {
29706   float jresult ;
29707   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
29708   float result;
29709
29710   arg1 = (Dali::Rect< float > *)jarg1;
29711   result = (float) ((arg1)->bottom);
29712   jresult = result;
29713   return jresult;
29714 }
29715
29716
29717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_top_set(void * jarg1, float jarg2) {
29718   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
29719   float arg2 ;
29720
29721   arg1 = (Dali::Rect< float > *)jarg1;
29722   arg2 = (float)jarg2;
29723   if (arg1) (arg1)->top = arg2;
29724 }
29725
29726
29727 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_top_get(void * jarg1) {
29728   float jresult ;
29729   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
29730   float result;
29731
29732   arg1 = (Dali::Rect< float > *)jarg1;
29733   result = (float) ((arg1)->top);
29734   jresult = result;
29735   return jresult;
29736 }
29737
29738
29739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PaddingType(void * jarg1) {
29740   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
29741
29742   arg1 = (Dali::Rect< float > *)jarg1;
29743   {
29744     try {
29745       delete arg1;
29746     } CALL_CATCH_EXCEPTION();
29747   }
29748
29749 }
29750
29751
29752 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorInteger_BaseType_get() {
29753   int jresult ;
29754   int result;
29755
29756   result = (int)Dali::Vector< int >::BaseType;
29757   jresult = (int)result;
29758   return jresult;
29759 }
29760
29761
29762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_0() {
29763   void * jresult ;
29764   Dali::Vector< int > *result = 0 ;
29765
29766   {
29767     try {
29768       result = (Dali::Vector< int > *)new Dali::Vector< int >();
29769     } CALL_CATCH_EXCEPTION(0);
29770   }
29771
29772   jresult = (void *)result;
29773   return jresult;
29774 }
29775
29776
29777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorInteger(void * jarg1) {
29778   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
29779
29780   arg1 = (Dali::Vector< int > *)jarg1;
29781   {
29782     try {
29783       delete arg1;
29784     } CALL_CATCH_EXCEPTION();
29785   }
29786
29787 }
29788
29789
29790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_1(void * jarg1) {
29791   void * jresult ;
29792   Dali::Vector< int > *arg1 = 0 ;
29793   Dali::Vector< int > *result = 0 ;
29794
29795   arg1 = (Dali::Vector< int > *)jarg1;
29796   if (!arg1) {
29797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
29798     return 0;
29799   }
29800   {
29801     try {
29802       result = (Dali::Vector< int > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1);
29803     } CALL_CATCH_EXCEPTION(0);
29804   }
29805
29806   jresult = (void *)result;
29807   return jresult;
29808 }
29809
29810
29811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Assign(void * jarg1, void * jarg2) {
29812   void * jresult ;
29813   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
29814   Dali::Vector< int > *arg2 = 0 ;
29815   Dali::Vector< int > *result = 0 ;
29816
29817   arg1 = (Dali::Vector< int > *)jarg1;
29818   arg2 = (Dali::Vector< int > *)jarg2;
29819   if (!arg2) {
29820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
29821     return 0;
29822   }
29823   {
29824     try {
29825       result = (Dali::Vector< int > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2);
29826     } CALL_CATCH_EXCEPTION(0);
29827   }
29828
29829   jresult = (void *)result;
29830   return jresult;
29831 }
29832
29833
29834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Begin(void * jarg1) {
29835   void * jresult ;
29836   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
29837   Dali::Vector< int >::Iterator result;
29838
29839   arg1 = (Dali::Vector< int > *)jarg1;
29840   {
29841     try {
29842       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin();
29843     } CALL_CATCH_EXCEPTION(0);
29844   }
29845
29846   jresult = (void *)result;
29847   return jresult;
29848 }
29849
29850
29851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_End(void * jarg1) {
29852   void * jresult ;
29853   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
29854   Dali::Vector< int >::Iterator result;
29855
29856   arg1 = (Dali::Vector< int > *)jarg1;
29857   {
29858     try {
29859       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->End();
29860     } CALL_CATCH_EXCEPTION(0);
29861   }
29862
29863   jresult = (void *)result;
29864   return jresult;
29865 }
29866
29867
29868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
29869   void * jresult ;
29870   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
29871   Dali::Vector< int >::SizeType arg2 ;
29872   Dali::Vector< int >::ItemType *result = 0 ;
29873
29874   arg1 = (Dali::Vector< int > *)jarg1;
29875   arg2 = (Dali::Vector< int >::SizeType)jarg2;
29876   {
29877     try {
29878       result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2);
29879     } CALL_CATCH_EXCEPTION(0);
29880   }
29881
29882   jresult = (void *)result;
29883   return jresult;
29884 }
29885
29886
29887 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_PushBack(void * jarg1, int jarg2) {
29888   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
29889   Dali::Vector< int >::ItemType *arg2 = 0 ;
29890   Dali::Vector< int >::ItemType temp2 ;
29891
29892   arg1 = (Dali::Vector< int > *)jarg1;
29893   temp2 = (Dali::Vector< int >::ItemType)jarg2;
29894   arg2 = &temp2;
29895   {
29896     try {
29897       (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2);
29898     } CALL_CATCH_EXCEPTION();
29899   }
29900
29901 }
29902
29903
29904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
29905   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
29906   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
29907   Dali::Vector< int >::ItemType *arg3 = 0 ;
29908   Dali::Vector< int >::ItemType temp3 ;
29909
29910   arg1 = (Dali::Vector< int > *)jarg1;
29911   arg2 = (Dali::Vector< int >::Iterator)jarg2;
29912   temp3 = (Dali::Vector< int >::ItemType)jarg3;
29913   arg3 = &temp3;
29914   {
29915     try {
29916       (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
29917     } CALL_CATCH_EXCEPTION();
29918   }
29919
29920 }
29921
29922
29923 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
29924   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
29925   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
29926   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
29927   Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ;
29928
29929   arg1 = (Dali::Vector< int > *)jarg1;
29930   arg2 = (Dali::Vector< int >::Iterator)jarg2;
29931   arg3 = (Dali::Vector< int >::Iterator)jarg3;
29932   arg4 = (Dali::Vector< int >::Iterator)jarg4;
29933   {
29934     try {
29935       (arg1)->Insert(arg2,arg3,arg4);
29936     } CALL_CATCH_EXCEPTION();
29937   }
29938
29939 }
29940
29941
29942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) {
29943   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
29944   Dali::Vector< int >::SizeType arg2 ;
29945
29946   arg1 = (Dali::Vector< int > *)jarg1;
29947   arg2 = (Dali::Vector< int >::SizeType)jarg2;
29948   {
29949     try {
29950       (arg1)->Reserve(arg2);
29951     } CALL_CATCH_EXCEPTION();
29952   }
29953
29954 }
29955
29956
29957 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
29958   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
29959   Dali::Vector< int >::SizeType arg2 ;
29960
29961   arg1 = (Dali::Vector< int > *)jarg1;
29962   arg2 = (Dali::Vector< int >::SizeType)jarg2;
29963   {
29964     try {
29965       (arg1)->Resize(arg2);
29966     } CALL_CATCH_EXCEPTION();
29967   }
29968
29969 }
29970
29971
29972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) {
29973   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
29974   Dali::Vector< int >::SizeType arg2 ;
29975   Dali::Vector< int >::ItemType *arg3 = 0 ;
29976   Dali::Vector< int >::ItemType temp3 ;
29977
29978   arg1 = (Dali::Vector< int > *)jarg1;
29979   arg2 = (Dali::Vector< int >::SizeType)jarg2;
29980   temp3 = (Dali::Vector< int >::ItemType)jarg3;
29981   arg3 = &temp3;
29982   {
29983     try {
29984       (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
29985     } CALL_CATCH_EXCEPTION();
29986   }
29987
29988 }
29989
29990
29991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) {
29992   void * jresult ;
29993   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
29994   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
29995   Dali::Vector< int >::Iterator result;
29996
29997   arg1 = (Dali::Vector< int > *)jarg1;
29998   arg2 = (Dali::Vector< int >::Iterator)jarg2;
29999   {
30000     try {
30001       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2);
30002     } CALL_CATCH_EXCEPTION(0);
30003   }
30004
30005   jresult = (void *)result;
30006   return jresult;
30007 }
30008
30009
30010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
30011   void * jresult ;
30012   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
30013   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
30014   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
30015   Dali::Vector< int >::Iterator result;
30016
30017   arg1 = (Dali::Vector< int > *)jarg1;
30018   arg2 = (Dali::Vector< int >::Iterator)jarg2;
30019   arg3 = (Dali::Vector< int >::Iterator)jarg3;
30020   {
30021     try {
30022       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3);
30023     } CALL_CATCH_EXCEPTION(0);
30024   }
30025
30026   jresult = (void *)result;
30027   return jresult;
30028 }
30029
30030
30031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Remove(void * jarg1, void * jarg2) {
30032   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
30033   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
30034
30035   arg1 = (Dali::Vector< int > *)jarg1;
30036   arg2 = (Dali::Vector< int >::Iterator)jarg2;
30037   {
30038     try {
30039       (arg1)->Remove(arg2);
30040     } CALL_CATCH_EXCEPTION();
30041   }
30042
30043 }
30044
30045
30046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Swap(void * jarg1, void * jarg2) {
30047   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
30048   Dali::Vector< int > *arg2 = 0 ;
30049
30050   arg1 = (Dali::Vector< int > *)jarg1;
30051   arg2 = (Dali::Vector< int > *)jarg2;
30052   if (!arg2) {
30053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0);
30054     return ;
30055   }
30056   {
30057     try {
30058       (arg1)->Swap(*arg2);
30059     } CALL_CATCH_EXCEPTION();
30060   }
30061
30062 }
30063
30064
30065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Clear(void * jarg1) {
30066   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
30067
30068   arg1 = (Dali::Vector< int > *)jarg1;
30069   {
30070     try {
30071       (arg1)->Clear();
30072     } CALL_CATCH_EXCEPTION();
30073   }
30074
30075 }
30076
30077
30078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Release(void * jarg1) {
30079   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
30080
30081   arg1 = (Dali::Vector< int > *)jarg1;
30082   {
30083     try {
30084       (arg1)->Release();
30085     } CALL_CATCH_EXCEPTION();
30086   }
30087
30088 }
30089
30090
30091 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorFloat_BaseType_get() {
30092   int jresult ;
30093   int result;
30094
30095   result = (int)Dali::Vector< float >::BaseType;
30096   jresult = (int)result;
30097   return jresult;
30098 }
30099
30100
30101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_0() {
30102   void * jresult ;
30103   Dali::Vector< float > *result = 0 ;
30104
30105   {
30106     try {
30107       result = (Dali::Vector< float > *)new Dali::Vector< float >();
30108     } CALL_CATCH_EXCEPTION(0);
30109   }
30110
30111   jresult = (void *)result;
30112   return jresult;
30113 }
30114
30115
30116 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorFloat(void * jarg1) {
30117   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30118
30119   arg1 = (Dali::Vector< float > *)jarg1;
30120   {
30121     try {
30122       delete arg1;
30123     } CALL_CATCH_EXCEPTION();
30124   }
30125
30126 }
30127
30128
30129 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_1(void * jarg1) {
30130   void * jresult ;
30131   Dali::Vector< float > *arg1 = 0 ;
30132   Dali::Vector< float > *result = 0 ;
30133
30134   arg1 = (Dali::Vector< float > *)jarg1;
30135   if (!arg1) {
30136     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
30137     return 0;
30138   }
30139   {
30140     try {
30141       result = (Dali::Vector< float > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1);
30142     } CALL_CATCH_EXCEPTION(0);
30143   }
30144
30145   jresult = (void *)result;
30146   return jresult;
30147 }
30148
30149
30150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Assign(void * jarg1, void * jarg2) {
30151   void * jresult ;
30152   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30153   Dali::Vector< float > *arg2 = 0 ;
30154   Dali::Vector< float > *result = 0 ;
30155
30156   arg1 = (Dali::Vector< float > *)jarg1;
30157   arg2 = (Dali::Vector< float > *)jarg2;
30158   if (!arg2) {
30159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
30160     return 0;
30161   }
30162   {
30163     try {
30164       result = (Dali::Vector< float > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2);
30165     } CALL_CATCH_EXCEPTION(0);
30166   }
30167
30168   jresult = (void *)result;
30169   return jresult;
30170 }
30171
30172
30173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Begin(void * jarg1) {
30174   void * jresult ;
30175   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30176   Dali::Vector< float >::Iterator result;
30177
30178   arg1 = (Dali::Vector< float > *)jarg1;
30179   {
30180     try {
30181       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin();
30182     } CALL_CATCH_EXCEPTION(0);
30183   }
30184
30185   jresult = (void *)result;
30186   return jresult;
30187 }
30188
30189
30190 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_End(void * jarg1) {
30191   void * jresult ;
30192   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30193   Dali::Vector< float >::Iterator result;
30194
30195   arg1 = (Dali::Vector< float > *)jarg1;
30196   {
30197     try {
30198       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->End();
30199     } CALL_CATCH_EXCEPTION(0);
30200   }
30201
30202   jresult = (void *)result;
30203   return jresult;
30204 }
30205
30206
30207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
30208   void * jresult ;
30209   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30210   Dali::Vector< float >::SizeType arg2 ;
30211   Dali::Vector< float >::ItemType *result = 0 ;
30212
30213   arg1 = (Dali::Vector< float > *)jarg1;
30214   arg2 = (Dali::Vector< float >::SizeType)jarg2;
30215   {
30216     try {
30217       result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2);
30218     } CALL_CATCH_EXCEPTION(0);
30219   }
30220
30221   jresult = (void *)result;
30222   return jresult;
30223 }
30224
30225
30226 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_PushBack(void * jarg1, float jarg2) {
30227   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30228   Dali::Vector< float >::ItemType *arg2 = 0 ;
30229   Dali::Vector< float >::ItemType temp2 ;
30230
30231   arg1 = (Dali::Vector< float > *)jarg1;
30232   temp2 = (Dali::Vector< float >::ItemType)jarg2;
30233   arg2 = &temp2;
30234   {
30235     try {
30236       (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2);
30237     } CALL_CATCH_EXCEPTION();
30238   }
30239
30240 }
30241
30242
30243 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) {
30244   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30245   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
30246   Dali::Vector< float >::ItemType *arg3 = 0 ;
30247   Dali::Vector< float >::ItemType temp3 ;
30248
30249   arg1 = (Dali::Vector< float > *)jarg1;
30250   arg2 = (Dali::Vector< float >::Iterator)jarg2;
30251   temp3 = (Dali::Vector< float >::ItemType)jarg3;
30252   arg3 = &temp3;
30253   {
30254     try {
30255       (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
30256     } CALL_CATCH_EXCEPTION();
30257   }
30258
30259 }
30260
30261
30262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
30263   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30264   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
30265   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
30266   Dali::Vector< float >::Iterator arg4 = (Dali::Vector< float >::Iterator) 0 ;
30267
30268   arg1 = (Dali::Vector< float > *)jarg1;
30269   arg2 = (Dali::Vector< float >::Iterator)jarg2;
30270   arg3 = (Dali::Vector< float >::Iterator)jarg3;
30271   arg4 = (Dali::Vector< float >::Iterator)jarg4;
30272   {
30273     try {
30274       (arg1)->Insert(arg2,arg3,arg4);
30275     } CALL_CATCH_EXCEPTION();
30276   }
30277
30278 }
30279
30280
30281 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) {
30282   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30283   Dali::Vector< float >::SizeType arg2 ;
30284
30285   arg1 = (Dali::Vector< float > *)jarg1;
30286   arg2 = (Dali::Vector< float >::SizeType)jarg2;
30287   {
30288     try {
30289       (arg1)->Reserve(arg2);
30290     } CALL_CATCH_EXCEPTION();
30291   }
30292
30293 }
30294
30295 //// ========================= end of part 2 =============================
30296
30297 //// ========================== start part 3 ===============================
30298
30299
30300 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
30301   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30302   Dali::Vector< float >::SizeType arg2 ;
30303
30304   arg1 = (Dali::Vector< float > *)jarg1;
30305   arg2 = (Dali::Vector< float >::SizeType)jarg2;
30306   {
30307     try {
30308       (arg1)->Resize(arg2);
30309     } CALL_CATCH_EXCEPTION();
30310   }
30311
30312 }
30313
30314
30315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) {
30316   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30317   Dali::Vector< float >::SizeType arg2 ;
30318   Dali::Vector< float >::ItemType *arg3 = 0 ;
30319   Dali::Vector< float >::ItemType temp3 ;
30320
30321   arg1 = (Dali::Vector< float > *)jarg1;
30322   arg2 = (Dali::Vector< float >::SizeType)jarg2;
30323   temp3 = (Dali::Vector< float >::ItemType)jarg3;
30324   arg3 = &temp3;
30325   {
30326     try {
30327       (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
30328     } CALL_CATCH_EXCEPTION();
30329   }
30330
30331 }
30332
30333
30334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) {
30335   void * jresult ;
30336   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30337   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
30338   Dali::Vector< float >::Iterator result;
30339
30340   arg1 = (Dali::Vector< float > *)jarg1;
30341   arg2 = (Dali::Vector< float >::Iterator)jarg2;
30342   {
30343     try {
30344       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2);
30345     } CALL_CATCH_EXCEPTION(0);
30346   }
30347
30348   jresult = (void *)result;
30349   return jresult;
30350 }
30351
30352
30353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
30354   void * jresult ;
30355   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30356   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
30357   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
30358   Dali::Vector< float >::Iterator result;
30359
30360   arg1 = (Dali::Vector< float > *)jarg1;
30361   arg2 = (Dali::Vector< float >::Iterator)jarg2;
30362   arg3 = (Dali::Vector< float >::Iterator)jarg3;
30363   {
30364     try {
30365       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3);
30366     } CALL_CATCH_EXCEPTION(0);
30367   }
30368
30369   jresult = (void *)result;
30370   return jresult;
30371 }
30372
30373
30374 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Remove(void * jarg1, void * jarg2) {
30375   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30376   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
30377
30378   arg1 = (Dali::Vector< float > *)jarg1;
30379   arg2 = (Dali::Vector< float >::Iterator)jarg2;
30380   {
30381     try {
30382       (arg1)->Remove(arg2);
30383     } CALL_CATCH_EXCEPTION();
30384   }
30385
30386 }
30387
30388
30389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Swap(void * jarg1, void * jarg2) {
30390   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30391   Dali::Vector< float > *arg2 = 0 ;
30392
30393   arg1 = (Dali::Vector< float > *)jarg1;
30394   arg2 = (Dali::Vector< float > *)jarg2;
30395   if (!arg2) {
30396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0);
30397     return ;
30398   }
30399   {
30400     try {
30401       (arg1)->Swap(*arg2);
30402     } CALL_CATCH_EXCEPTION();
30403   }
30404
30405 }
30406
30407
30408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Clear(void * jarg1) {
30409   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30410
30411   arg1 = (Dali::Vector< float > *)jarg1;
30412   {
30413     try {
30414       (arg1)->Clear();
30415     } CALL_CATCH_EXCEPTION();
30416   }
30417
30418 }
30419
30420
30421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Release(void * jarg1) {
30422   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30423
30424   arg1 = (Dali::Vector< float > *)jarg1;
30425   {
30426     try {
30427       (arg1)->Release();
30428     } CALL_CATCH_EXCEPTION();
30429   }
30430
30431 }
30432
30433
30434 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_BaseType_get() {
30435   int jresult ;
30436   int result;
30437
30438   result = (int)Dali::Vector< unsigned char >::BaseType;
30439   jresult = (int)result;
30440   return jresult;
30441 }
30442
30443
30444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_0() {
30445   void * jresult ;
30446   Dali::Vector< unsigned char > *result = 0 ;
30447
30448   {
30449     try {
30450       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >();
30451     } CALL_CATCH_EXCEPTION(0);
30452   }
30453
30454   jresult = (void *)result;
30455   return jresult;
30456 }
30457
30458
30459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUnsignedChar(void * jarg1) {
30460   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30461
30462   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30463   {
30464     try {
30465       delete arg1;
30466     } CALL_CATCH_EXCEPTION();
30467   }
30468
30469 }
30470
30471
30472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_1(void * jarg1) {
30473   void * jresult ;
30474   Dali::Vector< unsigned char > *arg1 = 0 ;
30475   Dali::Vector< unsigned char > *result = 0 ;
30476
30477   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30478   if (!arg1) {
30479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
30480     return 0;
30481   }
30482   {
30483     try {
30484       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > const &)*arg1);
30485     } CALL_CATCH_EXCEPTION(0);
30486   }
30487
30488   jresult = (void *)result;
30489   return jresult;
30490 }
30491
30492
30493 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Assign(void * jarg1, void * jarg2) {
30494   void * jresult ;
30495   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30496   Dali::Vector< unsigned char > *arg2 = 0 ;
30497   Dali::Vector< unsigned char > *result = 0 ;
30498
30499   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30500   arg2 = (Dali::Vector< unsigned char > *)jarg2;
30501   if (!arg2) {
30502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
30503     return 0;
30504   }
30505   {
30506     try {
30507       result = (Dali::Vector< unsigned char > *) &(arg1)->operator =((Dali::Vector< unsigned char > const &)*arg2);
30508     } CALL_CATCH_EXCEPTION(0);
30509   }
30510
30511   jresult = (void *)result;
30512   return jresult;
30513 }
30514
30515
30516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Begin(void * jarg1) {
30517   void * jresult ;
30518   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30519   Dali::Vector< unsigned char >::Iterator result;
30520
30521   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30522   {
30523     try {
30524       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin();
30525     } CALL_CATCH_EXCEPTION(0);
30526   }
30527
30528   jresult = (void *)result;
30529   return jresult;
30530 }
30531
30532
30533 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_End(void * jarg1) {
30534   void * jresult ;
30535   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30536   Dali::Vector< unsigned char >::Iterator result;
30537
30538   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30539   {
30540     try {
30541       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->End();
30542     } CALL_CATCH_EXCEPTION(0);
30543   }
30544
30545   jresult = (void *)result;
30546   return jresult;
30547 }
30548
30549
30550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
30551   void * jresult ;
30552   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30553   Dali::Vector< unsigned char >::SizeType arg2 ;
30554   Dali::Vector< unsigned char >::ItemType *result = 0 ;
30555
30556   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30557   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
30558   {
30559     try {
30560       result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2);
30561     } CALL_CATCH_EXCEPTION(0);
30562   }
30563
30564   jresult = (void *)result;
30565   return jresult;
30566 }
30567
30568
30569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) {
30570   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30571   Dali::Vector< unsigned char >::ItemType *arg2 = 0 ;
30572   Dali::Vector< unsigned char >::ItemType temp2 ;
30573
30574   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30575   temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2;
30576   arg2 = &temp2;
30577   {
30578     try {
30579       (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2);
30580     } CALL_CATCH_EXCEPTION();
30581   }
30582
30583 }
30584
30585
30586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) {
30587   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30588   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
30589   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
30590   Dali::Vector< unsigned char >::ItemType temp3 ;
30591
30592   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30593   arg2 = jarg2;
30594   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
30595   arg3 = &temp3;
30596   {
30597     try {
30598       (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
30599     } CALL_CATCH_EXCEPTION();
30600   }
30601
30602
30603
30604 }
30605
30606
30607 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) {
30608   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30609   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
30610   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
30611   Dali::Vector< unsigned char >::Iterator arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ;
30612
30613   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30614   arg2 = jarg2;
30615   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
30616   arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4;
30617   {
30618     try {
30619       (arg1)->Insert(arg2,arg3,arg4);
30620     } CALL_CATCH_EXCEPTION();
30621   }
30622
30623
30624
30625 }
30626
30627
30628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Reserve(void * jarg1, unsigned long jarg2) {
30629   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30630   Dali::Vector< unsigned char >::SizeType arg2 ;
30631
30632   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30633   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
30634   {
30635     try {
30636       (arg1)->Reserve(arg2);
30637     } CALL_CATCH_EXCEPTION();
30638   }
30639
30640 }
30641
30642
30643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
30644   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30645   Dali::Vector< unsigned char >::SizeType arg2 ;
30646
30647   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30648   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
30649   {
30650     try {
30651       (arg1)->Resize(arg2);
30652     } CALL_CATCH_EXCEPTION();
30653   }
30654
30655 }
30656
30657
30658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) {
30659   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30660   Dali::Vector< unsigned char >::SizeType arg2 ;
30661   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
30662   Dali::Vector< unsigned char >::ItemType temp3 ;
30663
30664   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30665   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
30666   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
30667   arg3 = &temp3;
30668   {
30669     try {
30670       (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
30671     } CALL_CATCH_EXCEPTION();
30672   }
30673
30674 }
30675
30676
30677 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) {
30678   void * jresult ;
30679   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30680   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
30681   Dali::Vector< unsigned char >::Iterator result;
30682
30683   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30684   arg2 = jarg2;
30685   {
30686     try {
30687       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2);
30688     } CALL_CATCH_EXCEPTION(0);
30689   }
30690
30691   jresult = (void *)result;
30692
30693
30694   return jresult;
30695 }
30696
30697
30698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) {
30699   void * jresult ;
30700   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30701   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
30702   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
30703   Dali::Vector< unsigned char >::Iterator result;
30704
30705   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30706   arg2 = jarg2;
30707   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
30708   {
30709     try {
30710       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3);
30711     } CALL_CATCH_EXCEPTION(0);
30712   }
30713
30714   jresult = (void *)result;
30715
30716
30717   return jresult;
30718 }
30719
30720
30721 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Remove(void * jarg1, unsigned char* jarg2) {
30722   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30723   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
30724
30725   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30726   arg2 = jarg2;
30727   {
30728     try {
30729       (arg1)->Remove(arg2);
30730     } CALL_CATCH_EXCEPTION();
30731   }
30732
30733
30734
30735 }
30736
30737
30738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) {
30739   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30740   Dali::Vector< unsigned char > *arg2 = 0 ;
30741
30742   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30743   arg2 = (Dali::Vector< unsigned char > *)jarg2;
30744   if (!arg2) {
30745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0);
30746     return ;
30747   }
30748   {
30749     try {
30750       (arg1)->Swap(*arg2);
30751     } CALL_CATCH_EXCEPTION();
30752   }
30753
30754 }
30755
30756
30757 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Clear(void * jarg1) {
30758   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30759
30760   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30761   {
30762     try {
30763       (arg1)->Clear();
30764     } CALL_CATCH_EXCEPTION();
30765   }
30766
30767 }
30768
30769
30770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Release(void * jarg1) {
30771   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30772
30773   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30774   {
30775     try {
30776       (arg1)->Release();
30777     } CALL_CATCH_EXCEPTION();
30778   }
30779
30780 }
30781
30782
30783 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUint16Pair_BaseType_get() {
30784   int jresult ;
30785   int result;
30786
30787   result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType;
30788   jresult = (int)result;
30789   return jresult;
30790 }
30791
30792
30793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_0() {
30794   void * jresult ;
30795   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
30796
30797   {
30798     try {
30799       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >();
30800     } CALL_CATCH_EXCEPTION(0);
30801   }
30802
30803   jresult = (void *)result;
30804   return jresult;
30805 }
30806
30807
30808 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUint16Pair(void * jarg1) {
30809   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
30810
30811   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
30812   {
30813     try {
30814       delete arg1;
30815     } CALL_CATCH_EXCEPTION();
30816   }
30817
30818 }
30819
30820
30821 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_1(void * jarg1) {
30822   void * jresult ;
30823   Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ;
30824   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
30825
30826   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
30827   if (!arg1) {
30828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
30829     return 0;
30830   }
30831   {
30832     try {
30833       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1);
30834     } CALL_CATCH_EXCEPTION(0);
30835   }
30836
30837   jresult = (void *)result;
30838   return jresult;
30839 }
30840
30841
30842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Assign(void * jarg1, void * jarg2) {
30843   void * jresult ;
30844   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
30845   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
30846   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
30847
30848   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
30849   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
30850   if (!arg2) {
30851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
30852     return 0;
30853   }
30854   {
30855     try {
30856       result = (Dali::Vector< Dali::Uint16Pair > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2);
30857     } CALL_CATCH_EXCEPTION(0);
30858   }
30859
30860   jresult = (void *)result;
30861   return jresult;
30862 }
30863
30864
30865 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Begin(void * jarg1) {
30866   void * jresult ;
30867   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
30868   Dali::Vector< Dali::Uint16Pair >::Iterator result;
30869
30870   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
30871   {
30872     try {
30873       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin();
30874     } CALL_CATCH_EXCEPTION(0);
30875   }
30876
30877   jresult = (void *)result;
30878   return jresult;
30879 }
30880
30881
30882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_End(void * jarg1) {
30883   void * jresult ;
30884   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
30885   Dali::Vector< Dali::Uint16Pair >::Iterator result;
30886
30887   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
30888   {
30889     try {
30890       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->End();
30891     } CALL_CATCH_EXCEPTION(0);
30892   }
30893
30894   jresult = (void *)result;
30895   return jresult;
30896 }
30897
30898
30899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
30900   void * jresult ;
30901   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
30902   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
30903   Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ;
30904
30905   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
30906   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
30907   {
30908     try {
30909       result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2);
30910     } CALL_CATCH_EXCEPTION(0);
30911   }
30912
30913   jresult = (void *)result;
30914   return jresult;
30915 }
30916
30917
30918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) {
30919   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
30920   Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ;
30921
30922   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
30923   arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2;
30924   if (!arg2) {
30925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
30926     return ;
30927   }
30928   {
30929     try {
30930       (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2);
30931     } CALL_CATCH_EXCEPTION();
30932   }
30933
30934 }
30935
30936
30937 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
30938   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
30939   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
30940   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
30941
30942   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
30943   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
30944   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
30945   if (!arg3) {
30946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
30947     return ;
30948   }
30949   {
30950     try {
30951       (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
30952     } CALL_CATCH_EXCEPTION();
30953   }
30954
30955 }
30956
30957
30958 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
30959   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
30960   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
30961   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
30962   Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
30963
30964   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
30965   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
30966   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
30967   arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4;
30968   {
30969     try {
30970       (arg1)->Insert(arg2,arg3,arg4);
30971     } CALL_CATCH_EXCEPTION();
30972   }
30973
30974 }
30975
30976
30977 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) {
30978   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
30979   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
30980
30981   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
30982   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
30983   {
30984     try {
30985       (arg1)->Reserve(arg2);
30986     } CALL_CATCH_EXCEPTION();
30987   }
30988
30989 }
30990
30991
30992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
30993   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
30994   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
30995
30996   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
30997   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
30998   {
30999     try {
31000       (arg1)->Resize(arg2);
31001     } CALL_CATCH_EXCEPTION();
31002   }
31003
31004 }
31005
31006
31007 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
31008   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
31009   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
31010   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
31011
31012   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
31013   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
31014   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
31015   if (!arg3) {
31016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
31017     return ;
31018   }
31019   {
31020     try {
31021       (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
31022     } CALL_CATCH_EXCEPTION();
31023   }
31024
31025 }
31026
31027
31028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_0(void * jarg1, void * jarg2) {
31029   void * jresult ;
31030   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
31031   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
31032   Dali::Vector< Dali::Uint16Pair >::Iterator result;
31033
31034   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
31035   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
31036   {
31037     try {
31038       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2);
31039     } CALL_CATCH_EXCEPTION(0);
31040   }
31041
31042   jresult = (void *)result;
31043   return jresult;
31044 }
31045
31046
31047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
31048   void * jresult ;
31049   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
31050   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
31051   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
31052   Dali::Vector< Dali::Uint16Pair >::Iterator result;
31053
31054   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
31055   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
31056   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
31057   {
31058     try {
31059       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3);
31060     } CALL_CATCH_EXCEPTION(0);
31061   }
31062
31063   jresult = (void *)result;
31064   return jresult;
31065 }
31066
31067
31068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Remove(void * jarg1, void * jarg2) {
31069   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
31070   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
31071
31072   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
31073   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
31074   {
31075     try {
31076       (arg1)->Remove(arg2);
31077     } CALL_CATCH_EXCEPTION();
31078   }
31079
31080 }
31081
31082
31083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Swap(void * jarg1, void * jarg2) {
31084   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
31085   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
31086
31087   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
31088   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
31089   if (!arg2) {
31090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0);
31091     return ;
31092   }
31093   {
31094     try {
31095       (arg1)->Swap(*arg2);
31096     } CALL_CATCH_EXCEPTION();
31097   }
31098
31099 }
31100
31101
31102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Clear(void * jarg1) {
31103   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
31104
31105   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
31106   {
31107     try {
31108       (arg1)->Clear();
31109     } CALL_CATCH_EXCEPTION();
31110   }
31111
31112 }
31113
31114
31115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Release(void * jarg1) {
31116   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
31117
31118   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
31119   {
31120     try {
31121       (arg1)->Release();
31122     } CALL_CATCH_EXCEPTION();
31123   }
31124
31125 }
31126
31127
31128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignal() {
31129   void * jresult ;
31130   Dali::Signal< void () > *result = 0 ;
31131
31132   {
31133     try {
31134       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
31135     } CALL_CATCH_EXCEPTION(0);
31136   }
31137
31138   jresult = (void *)result;
31139   return jresult;
31140 }
31141
31142
31143 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignal(void * jarg1) {
31144   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
31145
31146   arg1 = (Dali::Signal< void () > *)jarg1;
31147   {
31148     try {
31149       delete arg1;
31150     } CALL_CATCH_EXCEPTION();
31151   }
31152
31153 }
31154
31155
31156 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VoidSignal_Empty(void * jarg1) {
31157   unsigned int jresult ;
31158   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
31159   bool result;
31160
31161   arg1 = (Dali::Signal< void () > *)jarg1;
31162   {
31163     try {
31164       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
31165     } CALL_CATCH_EXCEPTION(0);
31166   }
31167
31168   jresult = result;
31169   return jresult;
31170 }
31171
31172
31173 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignal_GetConnectionCount(void * jarg1) {
31174   unsigned long jresult ;
31175   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
31176   std::size_t result;
31177
31178   arg1 = (Dali::Signal< void () > *)jarg1;
31179   {
31180     try {
31181       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
31182     } CALL_CATCH_EXCEPTION(0);
31183   }
31184
31185   jresult = (unsigned long)result;
31186   return jresult;
31187 }
31188
31189
31190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
31191   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
31192   void (*arg2)() = (void (*)()) 0 ;
31193
31194   arg1 = (Dali::Signal< void () > *)jarg1;
31195   arg2 = (void (*)())jarg2;
31196   {
31197     try {
31198       (arg1)->Connect(arg2);
31199     } CALL_CATCH_EXCEPTION();
31200   }
31201
31202 }
31203
31204
31205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Disconnect(void * jarg1, void * jarg2) {
31206   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
31207   void (*arg2)() = (void (*)()) 0 ;
31208
31209   arg1 = (Dali::Signal< void () > *)jarg1;
31210   arg2 = (void (*)())jarg2;
31211   {
31212     try {
31213       (arg1)->Disconnect(arg2);
31214     } CALL_CATCH_EXCEPTION();
31215   }
31216
31217 }
31218
31219
31220 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
31221   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
31222   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
31223   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
31224
31225   arg1 = (Dali::Signal< void () > *)jarg1;
31226   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
31227   arg3 = (Dali::FunctorDelegate *)jarg3;
31228   {
31229     try {
31230       (arg1)->Connect(arg2,arg3);
31231     } CALL_CATCH_EXCEPTION();
31232   }
31233
31234 }
31235
31236
31237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Emit(void * jarg1) {
31238   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
31239
31240   arg1 = (Dali::Signal< void () > *)jarg1;
31241   {
31242     try {
31243       (arg1)->Emit();
31244     } CALL_CATCH_EXCEPTION();
31245   }
31246
31247 }
31248
31249
31250 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FloatSignal_Empty(void * jarg1) {
31251   unsigned int jresult ;
31252   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
31253   bool result;
31254
31255   arg1 = (Dali::Signal< void (float) > *)jarg1;
31256   {
31257     try {
31258       result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1);
31259     } CALL_CATCH_EXCEPTION(0);
31260   }
31261
31262   jresult = result;
31263   return jresult;
31264 }
31265
31266
31267 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FloatSignal_GetConnectionCount(void * jarg1) {
31268   unsigned long jresult ;
31269   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
31270   std::size_t result;
31271
31272   arg1 = (Dali::Signal< void (float) > *)jarg1;
31273   {
31274     try {
31275       result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1);
31276     } CALL_CATCH_EXCEPTION(0);
31277   }
31278
31279   jresult = (unsigned long)result;
31280   return jresult;
31281 }
31282
31283
31284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Connect(void * jarg1, void * jarg2) {
31285   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
31286   void (*arg2)(float) = (void (*)(float)) 0 ;
31287
31288   arg1 = (Dali::Signal< void (float) > *)jarg1;
31289   arg2 = (void (*)(float))jarg2;
31290   {
31291     try {
31292       Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2);
31293     } CALL_CATCH_EXCEPTION();
31294   }
31295
31296 }
31297
31298
31299 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Disconnect(void * jarg1, void * jarg2) {
31300   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
31301   void (*arg2)(float) = (void (*)(float)) 0 ;
31302
31303   arg1 = (Dali::Signal< void (float) > *)jarg1;
31304   arg2 = (void (*)(float))jarg2;
31305   {
31306     try {
31307       Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(arg1,arg2);
31308     } CALL_CATCH_EXCEPTION();
31309   }
31310
31311 }
31312
31313
31314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Emit(void * jarg1, float jarg2) {
31315   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
31316   float arg2 ;
31317
31318   arg1 = (Dali::Signal< void (float) > *)jarg1;
31319   arg2 = (float)jarg2;
31320   {
31321     try {
31322       Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(arg1,arg2);
31323     } CALL_CATCH_EXCEPTION();
31324   }
31325
31326 }
31327
31328
31329 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FloatSignal() {
31330   void * jresult ;
31331   Dali::Signal< void (float) > *result = 0 ;
31332
31333   {
31334     try {
31335       result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >();
31336     } CALL_CATCH_EXCEPTION(0);
31337   }
31338
31339   jresult = (void *)result;
31340   return jresult;
31341 }
31342
31343
31344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FloatSignal(void * jarg1) {
31345   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
31346
31347   arg1 = (Dali::Signal< void (float) > *)jarg1;
31348   {
31349     try {
31350       delete arg1;
31351     } CALL_CATCH_EXCEPTION();
31352   }
31353
31354 }
31355
31356
31357 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Empty(void * jarg1) {
31358   unsigned int jresult ;
31359   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
31360   bool result;
31361
31362   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
31363   {
31364     try {
31365       result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
31366     } CALL_CATCH_EXCEPTION(0);
31367   }
31368
31369   jresult = result;
31370   return jresult;
31371 }
31372
31373
31374 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_GetConnectionCount(void * jarg1) {
31375   unsigned long jresult ;
31376   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
31377   std::size_t result;
31378
31379   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
31380   {
31381     try {
31382       result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
31383     } CALL_CATCH_EXCEPTION(0);
31384   }
31385
31386   jresult = (unsigned long)result;
31387   return jresult;
31388 }
31389
31390
31391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) {
31392   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
31393   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
31394
31395   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
31396   arg2 = (void (*)(Dali::BaseHandle))jarg2;
31397   {
31398     try {
31399       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2);
31400     } CALL_CATCH_EXCEPTION();
31401   }
31402
31403 }
31404
31405
31406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) {
31407   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
31408   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
31409
31410   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
31411   arg2 = (void (*)(Dali::BaseHandle))jarg2;
31412   {
31413     try {
31414       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2);
31415     } CALL_CATCH_EXCEPTION();
31416   }
31417
31418 }
31419
31420
31421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) {
31422   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
31423   Dali::BaseHandle arg2 ;
31424   Dali::BaseHandle *argp2 ;
31425
31426   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
31427   argp2 = (Dali::BaseHandle *)jarg2;
31428   if (!argp2) {
31429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
31430     return ;
31431   }
31432   arg2 = *argp2;
31433   {
31434     try {
31435       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(arg1,arg2);
31436     } CALL_CATCH_EXCEPTION();
31437   }
31438
31439 }
31440
31441
31442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectCreatedSignal() {
31443   void * jresult ;
31444   Dali::Signal< void (Dali::BaseHandle) > *result = 0 ;
31445
31446   {
31447     try {
31448       result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >();
31449     } CALL_CATCH_EXCEPTION(0);
31450   }
31451
31452   jresult = (void *)result;
31453   return jresult;
31454 }
31455
31456
31457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectCreatedSignal(void * jarg1) {
31458   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
31459
31460   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
31461   {
31462     try {
31463       delete arg1;
31464     } CALL_CATCH_EXCEPTION();
31465   }
31466
31467 }
31468
31469
31470 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Empty(void * jarg1) {
31471   unsigned int jresult ;
31472   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
31473   bool result;
31474
31475   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
31476   {
31477     try {
31478       result = (bool)Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
31479     } CALL_CATCH_EXCEPTION(0);
31480   }
31481
31482   jresult = result;
31483   return jresult;
31484 }
31485
31486
31487 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_GetConnectionCount(void * jarg1) {
31488   unsigned long jresult ;
31489   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
31490   std::size_t result;
31491
31492   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
31493   {
31494     try {
31495       result = Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
31496     } CALL_CATCH_EXCEPTION(0);
31497   }
31498
31499   jresult = (unsigned long)result;
31500   return jresult;
31501 }
31502
31503
31504 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Connect(void * jarg1, void * jarg2) {
31505   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
31506   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
31507
31508   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
31509   arg2 = (void (*)(Dali::RefObject const *))jarg2;
31510   {
31511     try {
31512       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(arg1,arg2);
31513     } CALL_CATCH_EXCEPTION();
31514   }
31515
31516 }
31517
31518
31519 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Disconnect(void * jarg1, void * jarg2) {
31520   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
31521   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
31522
31523   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
31524   arg2 = (void (*)(Dali::RefObject const *))jarg2;
31525   {
31526     try {
31527       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(arg1,arg2);
31528     } CALL_CATCH_EXCEPTION();
31529   }
31530
31531 }
31532
31533
31534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Emit(void * jarg1, void * jarg2) {
31535   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
31536   Dali::RefObject *arg2 = (Dali::RefObject *) 0 ;
31537
31538   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
31539   arg2 = (Dali::RefObject *)jarg2;
31540   {
31541     try {
31542       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(arg1,(Dali::RefObject const *)arg2);
31543     } CALL_CATCH_EXCEPTION();
31544   }
31545
31546 }
31547
31548
31549 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectDestroyedSignal() {
31550   void * jresult ;
31551   Dali::Signal< void (Dali::RefObject const *) > *result = 0 ;
31552
31553   {
31554     try {
31555       result = (Dali::Signal< void (Dali::RefObject const *) > *)new Dali::Signal< void (Dali::RefObject const *) >();
31556     } CALL_CATCH_EXCEPTION(0);
31557   }
31558
31559   jresult = (void *)result;
31560   return jresult;
31561 }
31562
31563
31564 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectDestroyedSignal(void * jarg1) {
31565   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
31566
31567   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
31568   {
31569     try {
31570       delete arg1;
31571     } CALL_CATCH_EXCEPTION();
31572   }
31573
31574 }
31575
31576
31577 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Empty(void * jarg1) {
31578   unsigned int jresult ;
31579   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
31580   bool result;
31581
31582   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
31583   {
31584     try {
31585       result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
31586     } CALL_CATCH_EXCEPTION(0);
31587   }
31588
31589   jresult = result;
31590   return jresult;
31591 }
31592
31593
31594 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_GetConnectionCount(void * jarg1) {
31595   unsigned long jresult ;
31596   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
31597   std::size_t result;
31598
31599   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
31600   {
31601     try {
31602       result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
31603     } CALL_CATCH_EXCEPTION(0);
31604   }
31605
31606   jresult = (unsigned long)result;
31607   return jresult;
31608 }
31609
31610
31611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) {
31612   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
31613   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
31614
31615   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
31616   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
31617   {
31618     try {
31619       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2);
31620     } CALL_CATCH_EXCEPTION();
31621   }
31622
31623 }
31624
31625
31626 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) {
31627   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
31628   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
31629
31630   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
31631   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
31632   {
31633     try {
31634       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2);
31635     } CALL_CATCH_EXCEPTION();
31636   }
31637
31638 }
31639
31640
31641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) {
31642   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
31643   Dali::PropertyNotification *arg2 = 0 ;
31644
31645   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
31646   arg2 = (Dali::PropertyNotification *)jarg2;
31647   if (!arg2) {
31648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0);
31649     return ;
31650   }
31651   {
31652     try {
31653       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(arg1,*arg2);
31654     } CALL_CATCH_EXCEPTION();
31655   }
31656
31657 }
31658
31659
31660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotifySignal() {
31661   void * jresult ;
31662   Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ;
31663
31664   {
31665     try {
31666       result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >();
31667     } CALL_CATCH_EXCEPTION(0);
31668   }
31669
31670   jresult = (void *)result;
31671   return jresult;
31672 }
31673
31674
31675 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotifySignal(void * jarg1) {
31676   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
31677
31678   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
31679   {
31680     try {
31681       delete arg1;
31682     } CALL_CATCH_EXCEPTION();
31683   }
31684
31685 }
31686
31687
31688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskSignal() {
31689   void * jresult ;
31690   Dali::Signal< void (Dali::RenderTask &) > *result = 0 ;
31691
31692   {
31693     try {
31694       result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >();
31695     } CALL_CATCH_EXCEPTION(0);
31696   }
31697
31698   jresult = (void *)result;
31699   return jresult;
31700 }
31701
31702
31703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskSignal(void * jarg1) {
31704   Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ;
31705
31706   arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1;
31707   {
31708     try {
31709       delete arg1;
31710     } CALL_CATCH_EXCEPTION();
31711   }
31712
31713 }
31714
31715
31716 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Empty(void * jarg1) {
31717   unsigned int jresult ;
31718   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
31719   bool result;
31720
31721   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
31722   {
31723     try {
31724       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);
31725     } CALL_CATCH_EXCEPTION(0);
31726   }
31727
31728   jresult = result;
31729   return jresult;
31730 }
31731
31732
31733 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) {
31734   unsigned long jresult ;
31735   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
31736   std::size_t result;
31737
31738   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
31739   {
31740     try {
31741       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);
31742     } CALL_CATCH_EXCEPTION(0);
31743   }
31744
31745   jresult = (unsigned long)result;
31746   return jresult;
31747 }
31748
31749
31750 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
31751   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
31752   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
31753
31754   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
31755   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
31756   {
31757     try {
31758       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
31759     } CALL_CATCH_EXCEPTION();
31760   }
31761
31762 }
31763
31764
31765 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
31766   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
31767   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
31768
31769   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
31770   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
31771   {
31772     try {
31773       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
31774     } CALL_CATCH_EXCEPTION();
31775   }
31776
31777 }
31778
31779
31780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
31781   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
31782   Dali::Actor arg2 ;
31783   Dali::LongPressGesture *arg3 = 0 ;
31784   Dali::Actor *argp2 ;
31785
31786   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
31787   argp2 = (Dali::Actor *)jarg2;
31788   if (!argp2) {
31789     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
31790     return ;
31791   }
31792   arg2 = *argp2;
31793   arg3 = (Dali::LongPressGesture *)jarg3;
31794   if (!arg3) {
31795     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
31796     return ;
31797   }
31798   {
31799     try {
31800       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture const &)*arg3);
31801     } CALL_CATCH_EXCEPTION();
31802   }
31803
31804 }
31805
31806
31807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetectedSignal() {
31808   void * jresult ;
31809   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ;
31810
31811   {
31812     try {
31813       result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >();
31814     } CALL_CATCH_EXCEPTION(0);
31815   }
31816
31817   jresult = (void *)result;
31818   return jresult;
31819 }
31820
31821
31822 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetectedSignal(void * jarg1) {
31823   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
31824
31825   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
31826   {
31827     try {
31828       delete arg1;
31829     } CALL_CATCH_EXCEPTION();
31830   }
31831
31832 }
31833
31834
31835 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Empty(void * jarg1) {
31836   unsigned int jresult ;
31837   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
31838   bool result;
31839
31840   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
31841   {
31842     try {
31843       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);
31844     } CALL_CATCH_EXCEPTION(0);
31845   }
31846
31847   jresult = result;
31848   return jresult;
31849 }
31850
31851
31852 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_GetConnectionCount(void * jarg1) {
31853   unsigned long jresult ;
31854   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
31855   std::size_t result;
31856
31857   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
31858   {
31859     try {
31860       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);
31861     } CALL_CATCH_EXCEPTION(0);
31862   }
31863
31864   jresult = (unsigned long)result;
31865   return jresult;
31866 }
31867
31868
31869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Connect(void * jarg1, void * jarg2) {
31870   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
31871   bool (*arg2)(Dali::Actor,Dali::TouchEvent const &) = (bool (*)(Dali::Actor,Dali::TouchEvent const &)) 0 ;
31872
31873   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
31874   arg2 = (bool (*)(Dali::Actor,Dali::TouchEvent const &))jarg2;
31875   {
31876     try {
31877       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
31878     } CALL_CATCH_EXCEPTION();
31879   }
31880
31881 }
31882
31883
31884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Disconnect(void * jarg1, void * jarg2) {
31885   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
31886   bool (*arg2)(Dali::Actor,Dali::TouchEvent const &) = (bool (*)(Dali::Actor,Dali::TouchEvent const &)) 0 ;
31887
31888   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
31889   arg2 = (bool (*)(Dali::Actor,Dali::TouchEvent const &))jarg2;
31890   {
31891     try {
31892       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
31893     } CALL_CATCH_EXCEPTION();
31894   }
31895
31896 }
31897
31898
31899 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
31900   unsigned int jresult ;
31901   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
31902   Dali::Actor arg2 ;
31903   Dali::TouchEvent *arg3 = 0 ;
31904   Dali::Actor *argp2 ;
31905   bool result;
31906
31907   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
31908   argp2 = (Dali::Actor *)jarg2;
31909   if (!argp2) {
31910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
31911     return 0;
31912   }
31913   arg2 = *argp2;
31914   arg3 = (Dali::TouchEvent *)jarg3;
31915   if (!arg3) {
31916     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
31917     return 0;
31918   }
31919   {
31920     try {
31921       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TouchEvent const &)*arg3);
31922     } CALL_CATCH_EXCEPTION(0);
31923   }
31924
31925   jresult = result;
31926   return jresult;
31927 }
31928
31929
31930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorTouchDataSignal() {
31931   void * jresult ;
31932   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *result = 0 ;
31933
31934   {
31935     try {
31936       result = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) >();
31937     } CALL_CATCH_EXCEPTION(0);
31938   }
31939
31940   jresult = (void *)result;
31941   return jresult;
31942 }
31943
31944
31945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorTouchDataSignal(void * jarg1) {
31946   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
31947
31948   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
31949   {
31950     try {
31951       delete arg1;
31952     } CALL_CATCH_EXCEPTION();
31953   }
31954
31955 }
31956
31957
31958 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Empty(void * jarg1) {
31959   unsigned int jresult ;
31960   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
31961   bool result;
31962
31963   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
31964   {
31965     try {
31966       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);
31967     } CALL_CATCH_EXCEPTION(0);
31968   }
31969
31970   jresult = result;
31971   return jresult;
31972 }
31973
31974
31975 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorHoverSignal_GetConnectionCount(void * jarg1) {
31976   unsigned long jresult ;
31977   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
31978   std::size_t result;
31979
31980   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
31981   {
31982     try {
31983       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);
31984     } CALL_CATCH_EXCEPTION(0);
31985   }
31986
31987   jresult = (unsigned long)result;
31988   return jresult;
31989 }
31990
31991
31992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Connect(void * jarg1, void * jarg2) {
31993   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
31994   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
31995
31996   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
31997   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
31998   {
31999     try {
32000       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
32001     } CALL_CATCH_EXCEPTION();
32002   }
32003
32004 }
32005
32006
32007 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Disconnect(void * jarg1, void * jarg2) {
32008   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
32009   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
32010
32011   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
32012   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
32013   {
32014     try {
32015       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
32016     } CALL_CATCH_EXCEPTION();
32017   }
32018
32019 }
32020
32021
32022 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
32023   unsigned int jresult ;
32024   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
32025   Dali::Actor arg2 ;
32026   Dali::HoverEvent *arg3 = 0 ;
32027   Dali::Actor *argp2 ;
32028   bool result;
32029
32030   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
32031   argp2 = (Dali::Actor *)jarg2;
32032   if (!argp2) {
32033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32034     return 0;
32035   }
32036   arg2 = *argp2;
32037   arg3 = (Dali::HoverEvent *)jarg3;
32038   if (!arg3) {
32039     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
32040     return 0;
32041   }
32042   {
32043     try {
32044       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::HoverEvent const &)*arg3);
32045     } CALL_CATCH_EXCEPTION(0);
32046   }
32047
32048   jresult = result;
32049   return jresult;
32050 }
32051
32052
32053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorHoverSignal() {
32054   void * jresult ;
32055   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *result = 0 ;
32056
32057   {
32058     try {
32059       result = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) >();
32060     } CALL_CATCH_EXCEPTION(0);
32061   }
32062
32063   jresult = (void *)result;
32064   return jresult;
32065 }
32066
32067
32068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorHoverSignal(void * jarg1) {
32069   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
32070
32071   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
32072   {
32073     try {
32074       delete arg1;
32075     } CALL_CATCH_EXCEPTION();
32076   }
32077
32078 }
32079
32080
32081 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Empty(void * jarg1) {
32082   unsigned int jresult ;
32083   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
32084   bool result;
32085
32086   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
32087   {
32088     try {
32089       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);
32090     } CALL_CATCH_EXCEPTION(0);
32091   }
32092
32093   jresult = result;
32094   return jresult;
32095 }
32096
32097
32098 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorWheelSignal_GetConnectionCount(void * jarg1) {
32099   unsigned long jresult ;
32100   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
32101   std::size_t result;
32102
32103   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
32104   {
32105     try {
32106       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);
32107     } CALL_CATCH_EXCEPTION(0);
32108   }
32109
32110   jresult = (unsigned long)result;
32111   return jresult;
32112 }
32113
32114
32115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Connect(void * jarg1, void * jarg2) {
32116   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
32117   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
32118
32119   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
32120   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
32121   {
32122     try {
32123       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
32124     } CALL_CATCH_EXCEPTION();
32125   }
32126
32127 }
32128
32129
32130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Disconnect(void * jarg1, void * jarg2) {
32131   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
32132   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
32133
32134   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
32135   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
32136   {
32137     try {
32138       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
32139     } CALL_CATCH_EXCEPTION();
32140   }
32141
32142 }
32143
32144
32145 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
32146   unsigned int jresult ;
32147   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
32148   Dali::Actor arg2 ;
32149   Dali::WheelEvent *arg3 = 0 ;
32150   Dali::Actor *argp2 ;
32151   bool result;
32152
32153   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
32154   argp2 = (Dali::Actor *)jarg2;
32155   if (!argp2) {
32156     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32157     return 0;
32158   }
32159   arg2 = *argp2;
32160   arg3 = (Dali::WheelEvent *)jarg3;
32161   if (!arg3) {
32162     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
32163     return 0;
32164   }
32165   {
32166     try {
32167       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::WheelEvent const &)*arg3);
32168     } CALL_CATCH_EXCEPTION(0);
32169   }
32170
32171   jresult = result;
32172   return jresult;
32173 }
32174
32175
32176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorWheelSignal() {
32177   void * jresult ;
32178   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *result = 0 ;
32179
32180   {
32181     try {
32182       result = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) >();
32183     } CALL_CATCH_EXCEPTION(0);
32184   }
32185
32186   jresult = (void *)result;
32187   return jresult;
32188 }
32189
32190
32191 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorWheelSignal(void * jarg1) {
32192   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
32193
32194   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
32195   {
32196     try {
32197       delete arg1;
32198     } CALL_CATCH_EXCEPTION();
32199   }
32200
32201 }
32202
32203
32204 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorSignal_Empty(void * jarg1) {
32205   unsigned int jresult ;
32206   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
32207   bool result;
32208
32209   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
32210   {
32211     try {
32212       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor) > const *)arg1);
32213     } CALL_CATCH_EXCEPTION(0);
32214   }
32215
32216   jresult = result;
32217   return jresult;
32218 }
32219
32220
32221 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorSignal_GetConnectionCount(void * jarg1) {
32222   unsigned long jresult ;
32223   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
32224   std::size_t result;
32225
32226   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
32227   {
32228     try {
32229       result = Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor) > const *)arg1);
32230     } CALL_CATCH_EXCEPTION(0);
32231   }
32232
32233   jresult = (unsigned long)result;
32234   return jresult;
32235 }
32236
32237
32238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Connect(void * jarg1, void * jarg2) {
32239   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
32240   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
32241
32242   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
32243   arg2 = (void (*)(Dali::Actor))jarg2;
32244   {
32245     try {
32246       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(arg1,arg2);
32247     } CALL_CATCH_EXCEPTION();
32248   }
32249
32250 }
32251
32252
32253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Disconnect(void * jarg1, void * jarg2) {
32254   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
32255   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
32256
32257   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
32258   arg2 = (void (*)(Dali::Actor))jarg2;
32259   {
32260     try {
32261       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
32262     } CALL_CATCH_EXCEPTION();
32263   }
32264
32265 }
32266
32267
32268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Emit(void * jarg1, void * jarg2) {
32269   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
32270   Dali::Actor arg2 ;
32271   Dali::Actor *argp2 ;
32272
32273   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
32274   argp2 = (Dali::Actor *)jarg2;
32275   if (!argp2) {
32276     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32277     return ;
32278   }
32279   arg2 = *argp2;
32280   {
32281     try {
32282       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(arg1,arg2);
32283     } CALL_CATCH_EXCEPTION();
32284   }
32285
32286 }
32287
32288
32289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorSignal() {
32290   void * jresult ;
32291   Dali::Signal< void (Dali::Actor) > *result = 0 ;
32292
32293   {
32294     try {
32295       result = (Dali::Signal< void (Dali::Actor) > *)new Dali::Signal< void (Dali::Actor) >();
32296     } CALL_CATCH_EXCEPTION(0);
32297   }
32298
32299   jresult = (void *)result;
32300   return jresult;
32301 }
32302
32303
32304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorSignal(void * jarg1) {
32305   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
32306
32307   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
32308   {
32309     try {
32310       delete arg1;
32311     } CALL_CATCH_EXCEPTION();
32312   }
32313
32314 }
32315
32316
32317 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyEventSignal_Empty(void * jarg1) {
32318   unsigned int jresult ;
32319   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
32320   bool result;
32321
32322   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
32323   {
32324     try {
32325       result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
32326     } CALL_CATCH_EXCEPTION(0);
32327   }
32328
32329   jresult = result;
32330   return jresult;
32331 }
32332
32333
32334 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyEventSignal_GetConnectionCount(void * jarg1) {
32335   unsigned long jresult ;
32336   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
32337   std::size_t result;
32338
32339   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
32340   {
32341     try {
32342       result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
32343     } CALL_CATCH_EXCEPTION(0);
32344   }
32345
32346   jresult = (unsigned long)result;
32347   return jresult;
32348 }
32349
32350
32351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Connect(void * jarg1, void * jarg2) {
32352   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
32353   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
32354
32355   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
32356   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
32357   {
32358     try {
32359       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
32360     } CALL_CATCH_EXCEPTION();
32361   }
32362
32363 }
32364
32365
32366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
32367   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
32368   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
32369
32370   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
32371   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
32372   {
32373     try {
32374       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
32375     } CALL_CATCH_EXCEPTION();
32376   }
32377
32378 }
32379
32380
32381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Emit(void * jarg1, void * jarg2) {
32382   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
32383   Dali::KeyEvent *arg2 = 0 ;
32384
32385   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
32386   arg2 = (Dali::KeyEvent *)jarg2;
32387   if (!arg2) {
32388     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32389     return ;
32390   }
32391   {
32392     try {
32393       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*arg2);
32394     } CALL_CATCH_EXCEPTION();
32395   }
32396
32397 }
32398
32399
32400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyEventSignal() {
32401   void * jresult ;
32402   Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ;
32403
32404   {
32405     try {
32406       result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >();
32407     } CALL_CATCH_EXCEPTION(0);
32408   }
32409
32410   jresult = (void *)result;
32411   return jresult;
32412 }
32413
32414
32415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyEventSignal(void * jarg1) {
32416   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
32417
32418   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
32419   {
32420     try {
32421       delete arg1;
32422     } CALL_CATCH_EXCEPTION();
32423   }
32424
32425 }
32426
32427
32428 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TouchSignal_Empty(void * jarg1) {
32429   unsigned int jresult ;
32430   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
32431   bool result;
32432
32433   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
32434   {
32435     try {
32436       result = (bool)Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::TouchEvent const &) > const *)arg1);
32437     } CALL_CATCH_EXCEPTION(0);
32438   }
32439
32440   jresult = result;
32441   return jresult;
32442 }
32443
32444
32445 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchSignal_GetConnectionCount(void * jarg1) {
32446   unsigned long jresult ;
32447   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
32448   std::size_t result;
32449
32450   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
32451   {
32452     try {
32453       result = Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::TouchEvent const &) > const *)arg1);
32454     } CALL_CATCH_EXCEPTION(0);
32455   }
32456
32457   jresult = (unsigned long)result;
32458   return jresult;
32459 }
32460
32461
32462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Connect(void * jarg1, void * jarg2) {
32463   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
32464   void (*arg2)(Dali::TouchEvent const &) = (void (*)(Dali::TouchEvent const &)) 0 ;
32465
32466   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
32467   arg2 = (void (*)(Dali::TouchEvent const &))jarg2;
32468   {
32469     try {
32470       Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
32471     } CALL_CATCH_EXCEPTION();
32472   }
32473
32474 }
32475
32476
32477 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Disconnect(void * jarg1, void * jarg2) {
32478   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
32479   void (*arg2)(Dali::TouchEvent const &) = (void (*)(Dali::TouchEvent const &)) 0 ;
32480
32481   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
32482   arg2 = (void (*)(Dali::TouchEvent const &))jarg2;
32483   {
32484     try {
32485       Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
32486     } CALL_CATCH_EXCEPTION();
32487   }
32488
32489 }
32490
32491
32492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Emit(void * jarg1, void * jarg2) {
32493   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
32494   Dali::TouchEvent *arg2 = 0 ;
32495
32496   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
32497   arg2 = (Dali::TouchEvent *)jarg2;
32498   if (!arg2) {
32499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
32500     return ;
32501   }
32502   {
32503     try {
32504       Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::TouchEvent const &)*arg2);
32505     } CALL_CATCH_EXCEPTION();
32506   }
32507
32508 }
32509
32510
32511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchSignal() {
32512   void * jresult ;
32513   Dali::Signal< void (Dali::TouchEvent const &) > *result = 0 ;
32514
32515   {
32516     try {
32517       result = (Dali::Signal< void (Dali::TouchEvent const &) > *)new Dali::Signal< void (Dali::TouchEvent const &) >();
32518     } CALL_CATCH_EXCEPTION(0);
32519   }
32520
32521   jresult = (void *)result;
32522   return jresult;
32523 }
32524
32525
32526 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchSignal(void * jarg1) {
32527   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
32528
32529   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
32530   {
32531     try {
32532       delete arg1;
32533     } CALL_CATCH_EXCEPTION();
32534   }
32535
32536 }
32537
32538
32539 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StageWheelSignal_Empty(void * jarg1) {
32540   unsigned int jresult ;
32541   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
32542   bool result;
32543
32544   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
32545   {
32546     try {
32547       result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
32548     } CALL_CATCH_EXCEPTION(0);
32549   }
32550
32551   jresult = result;
32552   return jresult;
32553 }
32554
32555
32556 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StageWheelSignal_GetConnectionCount(void * jarg1) {
32557   unsigned long jresult ;
32558   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
32559   std::size_t result;
32560
32561   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
32562   {
32563     try {
32564       result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
32565     } CALL_CATCH_EXCEPTION(0);
32566   }
32567
32568   jresult = (unsigned long)result;
32569   return jresult;
32570 }
32571
32572
32573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Connect(void * jarg1, void * jarg2) {
32574   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
32575   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
32576
32577   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
32578   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
32579   {
32580     try {
32581       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
32582     } CALL_CATCH_EXCEPTION();
32583   }
32584
32585 }
32586
32587
32588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Disconnect(void * jarg1, void * jarg2) {
32589   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
32590   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
32591
32592   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
32593   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
32594   {
32595     try {
32596       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
32597     } CALL_CATCH_EXCEPTION();
32598   }
32599
32600 }
32601
32602
32603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Emit(void * jarg1, void * jarg2) {
32604   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
32605   Dali::WheelEvent *arg2 = 0 ;
32606
32607   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
32608   arg2 = (Dali::WheelEvent *)jarg2;
32609   if (!arg2) {
32610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
32611     return ;
32612   }
32613   {
32614     try {
32615       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2);
32616     } CALL_CATCH_EXCEPTION();
32617   }
32618
32619 }
32620
32621
32622 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StageWheelSignal() {
32623   void * jresult ;
32624   Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ;
32625
32626   {
32627     try {
32628       result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >();
32629     } CALL_CATCH_EXCEPTION(0);
32630   }
32631
32632   jresult = (void *)result;
32633   return jresult;
32634 }
32635
32636
32637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StageWheelSignal(void * jarg1) {
32638   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
32639
32640   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
32641   {
32642     try {
32643       delete arg1;
32644     } CALL_CATCH_EXCEPTION();
32645   }
32646
32647 }
32648
32649
32650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_0() {
32651   void * jresult ;
32652   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
32653
32654   {
32655     try {
32656       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >();
32657     } CALL_CATCH_EXCEPTION(0);
32658   }
32659
32660   jresult = (void *)result;
32661   return jresult;
32662 }
32663
32664
32665 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) {
32666   void * jresult ;
32667   Dali::Radian arg1 ;
32668   Dali::Radian arg2 ;
32669   Dali::Radian *argp1 ;
32670   Dali::Radian *argp2 ;
32671   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
32672
32673   argp1 = (Dali::Radian *)jarg1;
32674   if (!argp1) {
32675     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
32676     return 0;
32677   }
32678   arg1 = *argp1;
32679   argp2 = (Dali::Radian *)jarg2;
32680   if (!argp2) {
32681     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
32682     return 0;
32683   }
32684   arg2 = *argp2;
32685   {
32686     try {
32687       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2);
32688     } CALL_CATCH_EXCEPTION(0);
32689   }
32690
32691   jresult = (void *)result;
32692   return jresult;
32693 }
32694
32695
32696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_2(void * jarg1) {
32697   void * jresult ;
32698   std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ;
32699   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
32700
32701   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
32702   if (!arg1) {
32703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0);
32704     return 0;
32705   }
32706   {
32707     try {
32708       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > const &)*arg1);
32709     } CALL_CATCH_EXCEPTION(0);
32710   }
32711
32712   jresult = (void *)result;
32713   return jresult;
32714 }
32715
32716
32717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_set(void * jarg1, void * jarg2) {
32718   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
32719   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
32720
32721   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
32722   arg2 = (Dali::Radian *)jarg2;
32723   if (arg1) (arg1)->first = *arg2;
32724 }
32725
32726
32727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_get(void * jarg1) {
32728   void * jresult ;
32729   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
32730   Dali::Radian *result = 0 ;
32731
32732   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
32733   result = (Dali::Radian *)& ((arg1)->first);
32734   jresult = (void *)result;
32735   return jresult;
32736 }
32737
32738
32739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_set(void * jarg1, void * jarg2) {
32740   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
32741   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
32742
32743   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
32744   arg2 = (Dali::Radian *)jarg2;
32745   if (arg1) (arg1)->second = *arg2;
32746 }
32747
32748
32749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_get(void * jarg1) {
32750   void * jresult ;
32751   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
32752   Dali::Radian *result = 0 ;
32753
32754   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
32755   result = (Dali::Radian *)& ((arg1)->second);
32756   jresult = (void *)result;
32757   return jresult;
32758 }
32759
32760
32761 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleThresholdPair(void * jarg1) {
32762   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
32763
32764   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
32765   {
32766     try {
32767       delete arg1;
32768     } CALL_CATCH_EXCEPTION();
32769   }
32770
32771 }
32772
32773
32774 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Empty(void * jarg1) {
32775   unsigned int jresult ;
32776   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
32777   bool result;
32778
32779   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
32780   {
32781     try {
32782       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);
32783     } CALL_CATCH_EXCEPTION(0);
32784   }
32785
32786   jresult = result;
32787   return jresult;
32788 }
32789
32790
32791 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) {
32792   unsigned long jresult ;
32793   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
32794   std::size_t result;
32795
32796   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
32797   {
32798     try {
32799       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);
32800     } CALL_CATCH_EXCEPTION(0);
32801   }
32802
32803   jresult = (unsigned long)result;
32804   return jresult;
32805 }
32806
32807
32808 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
32809   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
32810   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
32811
32812   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
32813   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
32814   {
32815     try {
32816       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
32817     } CALL_CATCH_EXCEPTION();
32818   }
32819
32820 }
32821
32822
32823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
32824   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
32825   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
32826
32827   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
32828   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
32829   {
32830     try {
32831       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
32832     } CALL_CATCH_EXCEPTION();
32833   }
32834
32835 }
32836
32837
32838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
32839   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
32840   Dali::Actor arg2 ;
32841   Dali::PanGesture *arg3 = 0 ;
32842   Dali::Actor *argp2 ;
32843
32844   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
32845   argp2 = (Dali::Actor *)jarg2;
32846   if (!argp2) {
32847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32848     return ;
32849   }
32850   arg2 = *argp2;
32851   arg3 = (Dali::PanGesture *)jarg3;
32852   if (!arg3) {
32853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
32854     return ;
32855   }
32856   {
32857     try {
32858       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*arg3);
32859     } CALL_CATCH_EXCEPTION();
32860   }
32861
32862 }
32863
32864
32865 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetectedSignal() {
32866   void * jresult ;
32867   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ;
32868
32869   {
32870     try {
32871       result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >();
32872     } CALL_CATCH_EXCEPTION(0);
32873   }
32874
32875   jresult = (void *)result;
32876   return jresult;
32877 }
32878
32879
32880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetectedSignal(void * jarg1) {
32881   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
32882
32883   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
32884   {
32885     try {
32886       delete arg1;
32887     } CALL_CATCH_EXCEPTION();
32888   }
32889
32890 }
32891
32892
32893 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Empty(void * jarg1) {
32894   unsigned int jresult ;
32895   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
32896   bool result;
32897
32898   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
32899   {
32900     try {
32901       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);
32902     } CALL_CATCH_EXCEPTION(0);
32903   }
32904
32905   jresult = result;
32906   return jresult;
32907 }
32908
32909
32910 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) {
32911   unsigned long jresult ;
32912   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
32913   std::size_t result;
32914
32915   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
32916   {
32917     try {
32918       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);
32919     } CALL_CATCH_EXCEPTION(0);
32920   }
32921
32922   jresult = (unsigned long)result;
32923   return jresult;
32924 }
32925
32926
32927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
32928   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
32929   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
32930
32931   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
32932   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
32933   {
32934     try {
32935       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
32936     } CALL_CATCH_EXCEPTION();
32937   }
32938
32939 }
32940
32941
32942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
32943   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
32944   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
32945
32946   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
32947   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
32948   {
32949     try {
32950       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
32951     } CALL_CATCH_EXCEPTION();
32952   }
32953
32954 }
32955
32956
32957 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
32958   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
32959   Dali::Actor arg2 ;
32960   Dali::PinchGesture *arg3 = 0 ;
32961   Dali::Actor *argp2 ;
32962
32963   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
32964   argp2 = (Dali::Actor *)jarg2;
32965   if (!argp2) {
32966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32967     return ;
32968   }
32969   arg2 = *argp2;
32970   arg3 = (Dali::PinchGesture *)jarg3;
32971   if (!arg3) {
32972     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
32973     return ;
32974   }
32975   {
32976     try {
32977       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3);
32978     } CALL_CATCH_EXCEPTION();
32979   }
32980
32981 }
32982
32983
32984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetectedSignal() {
32985   void * jresult ;
32986   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ;
32987
32988   {
32989     try {
32990       result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >();
32991     } CALL_CATCH_EXCEPTION(0);
32992   }
32993
32994   jresult = (void *)result;
32995   return jresult;
32996 }
32997
32998
32999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetectedSignal(void * jarg1) {
33000   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
33001
33002   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
33003   {
33004     try {
33005       delete arg1;
33006     } CALL_CATCH_EXCEPTION();
33007   }
33008
33009 }
33010
33011
33012 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Empty(void * jarg1) {
33013   unsigned int jresult ;
33014   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
33015   bool result;
33016
33017   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
33018   {
33019     try {
33020       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);
33021     } CALL_CATCH_EXCEPTION(0);
33022   }
33023
33024   jresult = result;
33025   return jresult;
33026 }
33027
33028
33029 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) {
33030   unsigned long jresult ;
33031   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
33032   std::size_t result;
33033
33034   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
33035   {
33036     try {
33037       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);
33038     } CALL_CATCH_EXCEPTION(0);
33039   }
33040
33041   jresult = (unsigned long)result;
33042   return jresult;
33043 }
33044
33045
33046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
33047   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
33048   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
33049
33050   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
33051   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
33052   {
33053     try {
33054       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
33055     } CALL_CATCH_EXCEPTION();
33056   }
33057
33058 }
33059
33060
33061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
33062   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
33063   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
33064
33065   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
33066   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
33067   {
33068     try {
33069       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
33070     } CALL_CATCH_EXCEPTION();
33071   }
33072
33073 }
33074
33075
33076 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
33077   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
33078   Dali::Actor arg2 ;
33079   Dali::TapGesture *arg3 = 0 ;
33080   Dali::Actor *argp2 ;
33081
33082   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
33083   argp2 = (Dali::Actor *)jarg2;
33084   if (!argp2) {
33085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33086     return ;
33087   }
33088   arg2 = *argp2;
33089   arg3 = (Dali::TapGesture *)jarg3;
33090   if (!arg3) {
33091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
33092     return ;
33093   }
33094   {
33095     try {
33096       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3);
33097     } CALL_CATCH_EXCEPTION();
33098   }
33099
33100 }
33101
33102
33103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetectedSignal() {
33104   void * jresult ;
33105   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ;
33106
33107   {
33108     try {
33109       result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >();
33110     } CALL_CATCH_EXCEPTION(0);
33111   }
33112
33113   jresult = (void *)result;
33114   return jresult;
33115 }
33116
33117
33118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetectedSignal(void * jarg1) {
33119   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
33120
33121   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
33122   {
33123     try {
33124       delete arg1;
33125     } CALL_CATCH_EXCEPTION();
33126   }
33127
33128 }
33129
33130
33131 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionChangedSignal_Empty(void * jarg1) {
33132   unsigned int jresult ;
33133   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
33134   bool result = false;
33135
33136   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
33137   {
33138     try {
33139       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);
33140     } CALL_CATCH_EXCEPTION(0);
33141   }
33142   jresult = result;
33143   return jresult;
33144 }
33145
33146 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_GetConnectionCount(void * jarg1) {
33147   unsigned long jresult ;
33148   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
33149   std::size_t result = 0;
33150
33151   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
33152   {
33153     try {
33154       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);
33155     }CALL_CATCH_EXCEPTION(0);
33156   }
33157   jresult = (unsigned long)result;
33158   return jresult;
33159 }
33160
33161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Connect(void * jarg1, void * jarg2) {
33162   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
33163   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
33164
33165   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
33166   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
33167   {
33168     try {
33169       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Connect(arg1,arg2);
33170     } CALL_CATCH_EXCEPTION();
33171   }
33172 }
33173
33174 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Disconnect(void * jarg1, void * jarg2) {
33175   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
33176   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
33177
33178   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
33179   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
33180   {
33181     try {
33182       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Disconnect(arg1,arg2);
33183     } CALL_CATCH_EXCEPTION();
33184   }
33185 }
33186
33187 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Emit(void * jarg1, void * jarg2, int jarg4) {
33188   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
33189   Dali::Actor arg2 ;
33190   //bool arg3 ;
33191   Dali::LayoutDirection::Type arg4 ;
33192   Dali::Actor *argp2 ;
33193
33194   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
33195   argp2 = (Dali::Actor *)jarg2;
33196   if (!argp2) {
33197     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33198     return ;
33199   }
33200   arg2 = *argp2;
33201   //arg3 = jarg3 ? true : false;
33202   arg4 = (Dali::LayoutDirection::Type)jarg4;
33203   {
33204     try {
33205       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Emit(arg1,arg2,arg4);
33206     } CALL_CATCH_EXCEPTION();
33207   }
33208 }
33209
33210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewLayoutDirectionSignal() {
33211   void * jresult ;
33212   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *result = 0 ;
33213
33214   {
33215     try {
33216       result = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)new Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) >();
33217     } CALL_CATCH_EXCEPTION(0);
33218   }
33219   jresult = (void *)result;
33220   return jresult;
33221 }
33222
33223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewLayoutDirectionSignal(void * jarg1) {
33224   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
33225
33226   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
33227   {
33228     try {
33229       delete arg1;
33230     } CALL_CATCH_EXCEPTION();
33231   }
33232 }
33233
33234
33235 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_iewVisibilityChangedSignal_Empty(void * jarg1) {
33236   unsigned int jresult ;
33237   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
33238   bool result = false;
33239
33240   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
33241   {
33242     try {
33243           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);
33244     } CALL_CATCH_EXCEPTION(0);
33245   }
33246   jresult = result;
33247   return jresult;
33248 }
33249
33250
33251 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_GetConnectionCount(void * jarg1) {
33252   unsigned long jresult ;
33253   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
33254   std::size_t result;
33255
33256   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
33257   {
33258     try {
33259       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);
33260     } CALL_CATCH_EXCEPTION(0);
33261   }
33262
33263   jresult = (unsigned long)result;
33264   return jresult;
33265 }
33266
33267
33268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Connect(void * jarg1, void * jarg2) {
33269   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
33270   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
33271
33272   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
33273   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
33274   {
33275     try {
33276       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(arg1,arg2);
33277     } CALL_CATCH_EXCEPTION();
33278   }
33279
33280 }
33281
33282
33283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Disconnect(void * jarg1, void * jarg2) {
33284   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
33285   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
33286
33287   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
33288   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
33289   {
33290     try {
33291       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(arg1,arg2);
33292     } CALL_CATCH_EXCEPTION();
33293   }
33294
33295 }
33296
33297
33298 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, int jarg4) {
33299   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
33300   Dali::Actor arg2 ;
33301   bool arg3 ;
33302   Dali::DevelActor::VisibilityChange::Type arg4 ;
33303   Dali::Actor *argp2 ;
33304
33305   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
33306   argp2 = (Dali::Actor *)jarg2;
33307   if (!argp2) {
33308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33309     return ;
33310   }
33311   arg2 = *argp2;
33312   arg3 = jarg3 ? true : false;
33313   arg4 = (Dali::DevelActor::VisibilityChange::Type)jarg4;
33314   {
33315     try {
33316       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(arg1,arg2,arg3,arg4);
33317     } CALL_CATCH_EXCEPTION();
33318   }
33319
33320 }
33321
33322
33323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewVisibilityChangedSignal() {
33324   void * jresult ;
33325   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *result = 0 ;
33326
33327   {
33328     try {
33329       result = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)new Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) >();
33330     } CALL_CATCH_EXCEPTION(0);
33331   }
33332
33333   jresult = (void *)result;
33334   return jresult;
33335 }
33336
33337
33338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewVisibilityChangedSignal(void * jarg1) {
33339   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
33340
33341   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
33342   {
33343     try {
33344       delete arg1;
33345     } CALL_CATCH_EXCEPTION();
33346   }
33347
33348 }
33349
33350
33351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_0() {
33352   void * jresult ;
33353   Dali::Timer *result = 0 ;
33354
33355   {
33356     try {
33357       result = (Dali::Timer *)new Dali::Timer();
33358     } CALL_CATCH_EXCEPTION(0);
33359   }
33360
33361   jresult = (void *)result;
33362   return jresult;
33363 }
33364
33365
33366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_New(unsigned int jarg1) {
33367   void * jresult ;
33368   unsigned int arg1 ;
33369   Dali::Timer result;
33370
33371   arg1 = (unsigned int)jarg1;
33372   {
33373     try {
33374       result = Dali::Timer::New(arg1);
33375     } CALL_CATCH_EXCEPTION(0);
33376   }
33377
33378   jresult = new Dali::Timer((const Dali::Timer &)result);
33379   return jresult;
33380 }
33381
33382
33383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_1(void * jarg1) {
33384   void * jresult ;
33385   Dali::Timer *arg1 = 0 ;
33386   Dali::Timer *result = 0 ;
33387
33388   arg1 = (Dali::Timer *)jarg1;
33389   if (!arg1) {
33390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
33391     return 0;
33392   }
33393   {
33394     try {
33395       result = (Dali::Timer *)new Dali::Timer((Dali::Timer const &)*arg1);
33396     } CALL_CATCH_EXCEPTION(0);
33397   }
33398
33399   jresult = (void *)result;
33400   return jresult;
33401 }
33402
33403
33404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_Assign(void * jarg1, void * jarg2) {
33405   void * jresult ;
33406   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
33407   Dali::Timer *arg2 = 0 ;
33408   Dali::Timer *result = 0 ;
33409
33410   arg1 = (Dali::Timer *)jarg1;
33411   arg2 = (Dali::Timer *)jarg2;
33412   if (!arg2) {
33413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
33414     return 0;
33415   }
33416   {
33417     try {
33418       result = (Dali::Timer *) &(arg1)->operator =((Dali::Timer const &)*arg2);
33419     } CALL_CATCH_EXCEPTION(0);
33420   }
33421
33422   jresult = (void *)result;
33423   return jresult;
33424 }
33425
33426
33427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Timer(void * jarg1) {
33428   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
33429
33430   arg1 = (Dali::Timer *)jarg1;
33431   {
33432     try {
33433       delete arg1;
33434     } CALL_CATCH_EXCEPTION();
33435   }
33436
33437 }
33438
33439
33440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_DownCast(void * jarg1) {
33441   void * jresult ;
33442   Dali::BaseHandle arg1 ;
33443   Dali::BaseHandle *argp1 ;
33444   Dali::Timer result;
33445
33446   argp1 = (Dali::BaseHandle *)jarg1;
33447   if (!argp1) {
33448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
33449     return 0;
33450   }
33451   arg1 = *argp1;
33452   {
33453     try {
33454       result = Dali::Timer::DownCast(arg1);
33455     } CALL_CATCH_EXCEPTION(0);
33456   }
33457
33458   jresult = new Dali::Timer((const Dali::Timer &)result);
33459   return jresult;
33460 }
33461
33462
33463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Start(void * jarg1) {
33464   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
33465
33466   arg1 = (Dali::Timer *)jarg1;
33467   {
33468     try {
33469       (arg1)->Start();
33470     } CALL_CATCH_EXCEPTION();
33471   }
33472
33473 }
33474
33475
33476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Stop(void * jarg1) {
33477   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
33478
33479   arg1 = (Dali::Timer *)jarg1;
33480   {
33481     try {
33482       (arg1)->Stop();
33483     } CALL_CATCH_EXCEPTION();
33484   }
33485
33486 }
33487
33488
33489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_SetInterval(void * jarg1, unsigned int jarg2) {
33490   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
33491   unsigned int arg2 ;
33492
33493   arg1 = (Dali::Timer *)jarg1;
33494   arg2 = (unsigned int)jarg2;
33495   {
33496     try {
33497       (arg1)->SetInterval(arg2);
33498     } CALL_CATCH_EXCEPTION();
33499   }
33500
33501 }
33502
33503
33504 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_GetInterval(void * jarg1) {
33505   unsigned int jresult ;
33506   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
33507   unsigned int result;
33508
33509   arg1 = (Dali::Timer *)jarg1;
33510   {
33511     try {
33512       result = (unsigned int)((Dali::Timer const *)arg1)->GetInterval();
33513     } CALL_CATCH_EXCEPTION(0);
33514   }
33515
33516   jresult = result;
33517   return jresult;
33518 }
33519
33520
33521 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_IsRunning(void * jarg1) {
33522   unsigned int jresult ;
33523   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
33524   bool result;
33525
33526   arg1 = (Dali::Timer *)jarg1;
33527   {
33528     try {
33529       result = (bool)((Dali::Timer const *)arg1)->IsRunning();
33530     } CALL_CATCH_EXCEPTION(0);
33531   }
33532
33533   jresult = result;
33534   return jresult;
33535 }
33536
33537
33538 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_TickSignal(void * jarg1) {
33539   void * jresult ;
33540   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
33541   Dali::Timer::TimerSignalType *result = 0 ;
33542
33543   arg1 = (Dali::Timer *)jarg1;
33544   {
33545     try {
33546       result = (Dali::Timer::TimerSignalType *) &(arg1)->TickSignal();
33547     } CALL_CATCH_EXCEPTION(0);
33548   }
33549
33550   jresult = (void *)result;
33551   return jresult;
33552 }
33553
33554
33555 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Empty(void * jarg1) {
33556   unsigned int jresult ;
33557   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
33558   bool result;
33559
33560   arg1 = (Dali::Signal< bool () > *)jarg1;
33561   {
33562     try {
33563       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Empty((Dali::Signal< bool () > const *)arg1);
33564     } CALL_CATCH_EXCEPTION(0);
33565   }
33566
33567   jresult = result;
33568   return jresult;
33569 }
33570
33571
33572 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TimerSignalType_GetConnectionCount(void * jarg1) {
33573   unsigned long jresult ;
33574   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
33575   std::size_t result;
33576
33577   arg1 = (Dali::Signal< bool () > *)jarg1;
33578   {
33579     try {
33580       result = Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount((Dali::Signal< bool () > const *)arg1);
33581     } CALL_CATCH_EXCEPTION(0);
33582   }
33583
33584   jresult = (unsigned long)result;
33585   return jresult;
33586 }
33587
33588
33589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect(void * jarg1, void * jarg2) {
33590   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
33591   bool (*arg2)() = (bool (*)()) 0 ;
33592
33593   arg1 = (Dali::Signal< bool () > *)jarg1;
33594   arg2 = (bool (*)())jarg2;
33595   {
33596     try {
33597       Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(arg1,arg2);
33598     } CALL_CATCH_EXCEPTION();
33599   }
33600
33601 }
33602
33603
33604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Disconnect(void * jarg1, void * jarg2) {
33605   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
33606   bool (*arg2)() = (bool (*)()) 0 ;
33607
33608   arg1 = (Dali::Signal< bool () > *)jarg1;
33609   arg2 = (bool (*)())jarg2;
33610   {
33611     try {
33612       Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(arg1,arg2);
33613     } CALL_CATCH_EXCEPTION();
33614   }
33615
33616 }
33617
33618
33619 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Emit(void * jarg1) {
33620   unsigned int jresult ;
33621   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
33622   bool result;
33623
33624   arg1 = (Dali::Signal< bool () > *)jarg1;
33625   {
33626     try {
33627       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(arg1);
33628     } CALL_CATCH_EXCEPTION(0);
33629   }
33630
33631   jresult = result;
33632   return jresult;
33633 }
33634
33635
33636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimerSignalType() {
33637   void * jresult ;
33638   Dali::Signal< bool () > *result = 0 ;
33639
33640   {
33641     try {
33642       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
33643     } CALL_CATCH_EXCEPTION(0);
33644   }
33645
33646   jresult = (void *)result;
33647   return jresult;
33648 }
33649
33650
33651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimerSignalType(void * jarg1) {
33652   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
33653
33654   arg1 = (Dali::Signal< bool () > *)jarg1;
33655   {
33656     try {
33657       delete arg1;
33658     } CALL_CATCH_EXCEPTION();
33659   }
33660
33661 }
33662
33663
33664 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() {
33665   int jresult ;
33666   int result;
33667
33668   {
33669     try {
33670       result = (int)Dali::Toolkit::Visual::Property::TYPE;
33671     } CALL_CATCH_EXCEPTION(0);
33672   }
33673
33674   jresult = (int)result;
33675   return jresult;
33676 }
33677
33678
33679 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_SHADER_get() {
33680   int jresult ;
33681   int result;
33682
33683   {
33684     try {
33685       result = (int)Dali::Toolkit::Visual::Property::SHADER;
33686     } CALL_CATCH_EXCEPTION(0);
33687   }
33688
33689   jresult = (int)result;
33690   return jresult;
33691 }
33692
33693
33694 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_VERTEX_get() {
33695   int jresult ;
33696   int result;
33697
33698   {
33699     try {
33700       result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
33701     } CALL_CATCH_EXCEPTION(0);
33702   }
33703
33704   jresult = (int)result;
33705   return jresult;
33706 }
33707
33708
33709 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_FRAGMENT_get() {
33710   int jresult ;
33711   int result;
33712
33713   {
33714     try {
33715       result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER;
33716     } CALL_CATCH_EXCEPTION(0);
33717   }
33718
33719   jresult = (int)result;
33720   return jresult;
33721 }
33722
33723
33724 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_X_get() {
33725   int jresult ;
33726   int result;
33727
33728   {
33729     try {
33730       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X;
33731     } CALL_CATCH_EXCEPTION(0);
33732   }
33733
33734   jresult = (int)result;
33735   return jresult;
33736 }
33737
33738
33739 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_Y_get() {
33740   int jresult ;
33741   int result;
33742
33743   {
33744     try {
33745       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y;
33746     } CALL_CATCH_EXCEPTION(0);
33747   }
33748
33749   jresult = (int)result;
33750   return jresult;
33751 }
33752
33753
33754 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_HINTS_get() {
33755   int jresult ;
33756   int result;
33757
33758   {
33759     try {
33760       result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS;
33761     } CALL_CATCH_EXCEPTION(0);
33762   }
33763
33764   jresult = (int)result;
33765   return jresult;
33766 }
33767
33768
33769 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_COLOR_get() {
33770   int jresult ;
33771   int result;
33772
33773   {
33774     try {
33775       result = (int)Dali::Toolkit::BorderVisual::Property::COLOR;
33776     } CALL_CATCH_EXCEPTION(0);
33777   }
33778
33779   jresult = (int)result;
33780   return jresult;
33781 }
33782
33783
33784 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_SIZE_get() {
33785   int jresult ;
33786   int result;
33787
33788   {
33789     try {
33790       result = (int)Dali::Toolkit::BorderVisual::Property::SIZE;
33791     } CALL_CATCH_EXCEPTION(0);
33792   }
33793
33794   jresult = (int)result;
33795   return jresult;
33796 }
33797
33798
33799 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_ANTI_ALIASING_get() {
33800   int jresult ;
33801   int result;
33802
33803   {
33804     try {
33805       result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING;
33806     } CALL_CATCH_EXCEPTION(0);
33807   }
33808
33809   jresult = (int)result;
33810   return jresult;
33811 }
33812
33813
33814 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_COLOR_VISUAL_MIX_COLOR_get() {
33815   int jresult ;
33816   int result;
33817
33818   {
33819     try {
33820       result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR;
33821     } CALL_CATCH_EXCEPTION(0);
33822   }
33823
33824   jresult = (int)result;
33825   return jresult;
33826 }
33827
33828
33829 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_START_POSITION_get() {
33830   int jresult ;
33831   int result;
33832
33833   {
33834     try {
33835       result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION;
33836     } CALL_CATCH_EXCEPTION(0);
33837   }
33838
33839   jresult = (int)result;
33840   return jresult;
33841 }
33842
33843
33844 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_END_POSITION_get() {
33845   int jresult ;
33846   int result;
33847
33848   {
33849     try {
33850       result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION;
33851     } CALL_CATCH_EXCEPTION(0);
33852   }
33853
33854   jresult = (int)result;
33855   return jresult;
33856 }
33857
33858
33859 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_CENTER_get() {
33860   int jresult ;
33861   int result;
33862
33863   {
33864     try {
33865       result = (int)Dali::Toolkit::GradientVisual::Property::CENTER;
33866     } CALL_CATCH_EXCEPTION(0);
33867   }
33868
33869   jresult = (int)result;
33870   return jresult;
33871 }
33872
33873
33874 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_RADIUS_get() {
33875   int jresult ;
33876   int result;
33877
33878   {
33879     try {
33880       result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS;
33881     } CALL_CATCH_EXCEPTION(0);
33882   }
33883
33884   jresult = (int)result;
33885   return jresult;
33886 }
33887
33888
33889 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_OFFSET_get() {
33890   int jresult ;
33891   int result;
33892
33893   {
33894     try {
33895       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET;
33896     } CALL_CATCH_EXCEPTION(0);
33897   }
33898
33899   jresult = (int)result;
33900   return jresult;
33901 }
33902
33903
33904 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_COLOR_get() {
33905   int jresult ;
33906   int result;
33907
33908   {
33909     try {
33910       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR;
33911     } CALL_CATCH_EXCEPTION(0);
33912   }
33913
33914   jresult = (int)result;
33915   return jresult;
33916 }
33917
33918
33919 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_UNITS_get() {
33920   int jresult ;
33921   int result;
33922
33923   {
33924     try {
33925       result = (int)Dali::Toolkit::GradientVisual::Property::UNITS;
33926     } CALL_CATCH_EXCEPTION(0);
33927   }
33928
33929   jresult = (int)result;
33930   return jresult;
33931 }
33932
33933
33934 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_SPREAD_METHOD_get() {
33935   int jresult ;
33936   int result;
33937
33938   {
33939     try {
33940       result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD;
33941     } CALL_CATCH_EXCEPTION(0);
33942   }
33943
33944   jresult = (int)result;
33945   return jresult;
33946 }
33947
33948
33949 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_URL_get() {
33950   int jresult ;
33951   int result;
33952
33953   {
33954     try {
33955       result = (int)Dali::Toolkit::ImageVisual::Property::URL;
33956     } CALL_CATCH_EXCEPTION(0);
33957   }
33958
33959   jresult = (int)result;
33960   return jresult;
33961 }
33962
33963 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ALPHA_MASK_URL_get() {
33964   int jresult ;
33965   int result;
33966
33967   {
33968     try {
33969       result = (int)Dali::Toolkit::ImageVisual::Property::ALPHA_MASK_URL;
33970     } CALL_CATCH_EXCEPTION(0);
33971   }
33972
33973   jresult = (int)result;
33974   return jresult;
33975 }
33976
33977
33978 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BATCH_SIZE_get() {
33979   int jresult ;
33980   int result;
33981   {
33982     try
33983     {
33984       result = (int)Dali::Toolkit::ImageVisual::Property::BATCH_SIZE;
33985     } CALL_CATCH_EXCEPTION(0);
33986   }
33987
33988   jresult = (int)result;
33989   return jresult;
33990 }
33991
33992 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CACHE_SIZE_get() {
33993   int jresult ;
33994   int result;
33995   {
33996     try
33997     {
33998       result = (int)Dali::Toolkit::ImageVisual::Property::CACHE_SIZE;
33999     } CALL_CATCH_EXCEPTION(0);
34000   }
34001
34002   jresult = (int)result;
34003   return jresult;
34004 }
34005
34006 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FRAME_DELAY_get() {
34007   int jresult ;
34008   int result;
34009   {
34010     try
34011     {
34012       result = (int)Dali::Toolkit::ImageVisual::Property::FRAME_DELAY;
34013     } CALL_CATCH_EXCEPTION(0);
34014   }
34015
34016   jresult = (int)result;
34017   return jresult;
34018 }
34019
34020 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOOP_COUNT_get() {
34021   return (int)Dali::Toolkit::DevelImageVisual::Property::LOOP_COUNT;
34022 }
34023
34024 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_MASK_CONTENT_SCALE_get() {
34025   int jresult ;
34026   int result;
34027   {
34028     try
34029     {
34030       result = (int)Dali::Toolkit::ImageVisual::Property::MASK_CONTENT_SCALE;
34031     } CALL_CATCH_EXCEPTION(0);
34032   }
34033
34034   jresult = (int)result;
34035   return jresult;
34036 }
34037
34038 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CROP_TO_MASK_get() {
34039   int jresult ;
34040   int result;
34041   {
34042     try
34043     {
34044       result = (int)Dali::Toolkit::ImageVisual::Property::CROP_TO_MASK;
34045     } CALL_CATCH_EXCEPTION(0);
34046   }
34047
34048   jresult = (int)result;
34049   return jresult;
34050 }
34051
34052 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() {
34053   int jresult ;
34054   int result;
34055
34056   {
34057     try {
34058       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE;
34059     } CALL_CATCH_EXCEPTION(0);
34060   }
34061
34062   jresult = (int)result;
34063   return jresult;
34064 }
34065
34066
34067 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SAMPLING_MODE_get() {
34068   int jresult ;
34069   int result;
34070
34071   {
34072     try {
34073       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
34074     } CALL_CATCH_EXCEPTION(0);
34075   }
34076
34077   jresult = (int)result;
34078   return jresult;
34079 }
34080
34081 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_RELEASE_POLICY_get() {
34082   int jresult ;
34083   int result;
34084   {
34085     try
34086     {
34087       result = (int)Dali::Toolkit::ImageVisual::Property::RELEASE_POLICY;
34088     } CALL_CATCH_EXCEPTION(0);
34089   }
34090
34091   jresult = (int)result;
34092   return jresult;
34093 }
34094
34095 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOAD_POLICY_get() {
34096   int jresult ;
34097   int result;
34098   {
34099     try
34100     {
34101       result = (int)Dali::Toolkit::ImageVisual::Property::LOAD_POLICY;
34102     } CALL_CATCH_EXCEPTION(0);
34103   }
34104
34105   jresult = (int)result;
34106   return jresult;
34107 }
34108
34109 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ORIENTATION_CORRECTION_get() {
34110   int jresult ;
34111   int result;
34112   {
34113     try
34114     {
34115       result = (int)Dali::Toolkit::ImageVisual::Property::ORIENTATION_CORRECTION;
34116     } CALL_CATCH_EXCEPTION(0);
34117   }
34118
34119   jresult = (int)result;
34120   return jresult;
34121 }
34122
34123
34124 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_URL_get() {
34125   int jresult ;
34126   int result;
34127   {
34128     try
34129     {
34130       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE;
34131     } CALL_CATCH_EXCEPTION(0);
34132   }
34133
34134   jresult = (int)result;
34135   return jresult;
34136 }
34137
34138 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_ALPHA_get() {
34139   int jresult ;
34140   int result;
34141   {
34142     try
34143     {
34144       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA;
34145     } CALL_CATCH_EXCEPTION(0);
34146   }
34147
34148   jresult = (int)result;
34149   return jresult;
34150 }
34151
34152
34153
34154 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() {
34155   int jresult ;
34156   int result;
34157
34158   {
34159     try {
34160       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
34161     } CALL_CATCH_EXCEPTION(0);
34162   }
34163
34164   jresult = (int)result;
34165   return jresult;
34166 }
34167
34168
34169 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
34170   int jresult ;
34171   int result;
34172
34173   {
34174     try {
34175       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
34176     } CALL_CATCH_EXCEPTION(0);
34177   }
34178
34179   jresult = (int)result;
34180   return jresult;
34181 }
34182
34183
34184 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
34185   int jresult ;
34186   int result;
34187
34188   {
34189     try {
34190       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
34191     } CALL_CATCH_EXCEPTION(0);
34192   }
34193
34194   jresult = (int)result;
34195   return jresult;
34196 }
34197
34198
34199 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() {
34200   int jresult ;
34201   int result;
34202
34203   {
34204     try {
34205       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
34206     } CALL_CATCH_EXCEPTION(0);
34207   }
34208
34209   jresult = (int)result;
34210   return jresult;
34211 }
34212
34213
34214 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() {
34215   int jresult ;
34216   int result;
34217
34218   {
34219     try {
34220       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
34221     } CALL_CATCH_EXCEPTION(0);
34222   }
34223
34224   jresult = (int)result;
34225   return jresult;
34226 }
34227
34228
34229 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() {
34230   int jresult ;
34231   int result;
34232
34233   {
34234     try {
34235       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
34236     } CALL_CATCH_EXCEPTION(0);
34237   }
34238
34239   jresult = (int)result;
34240   return jresult;
34241 }
34242
34243
34244 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get() {
34245   int jresult ;
34246   int result;
34247
34248   {
34249     try {
34250       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
34251     } CALL_CATCH_EXCEPTION(0);
34252   }
34253
34254   jresult = (int)result;
34255   return jresult;
34256 }
34257
34258 SWIGEXPORT int SWIGSTDCALL CSharp_Image_Visual_BORDER_get() {
34259   int jresult ;
34260   int result;
34261
34262   {
34263     try {
34264       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER;
34265     } CALL_CATCH_EXCEPTION(0);
34266   }
34267
34268   jresult = (int)result;
34269   return jresult;
34270 }
34271
34272 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() {
34273   int jresult ;
34274   int result;
34275
34276   {
34277     try {
34278       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
34279     } CALL_CATCH_EXCEPTION(0);
34280   }
34281
34282   jresult = (int)result;
34283   return jresult;
34284 }
34285
34286
34287 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() {
34288   int jresult ;
34289   int result;
34290
34291   {
34292     try {
34293       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
34294     } CALL_CATCH_EXCEPTION(0);
34295   }
34296
34297   jresult = (int)result;
34298   return jresult;
34299 }
34300
34301
34302 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() {
34303   int jresult ;
34304   int result;
34305
34306   {
34307     try {
34308       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
34309     } CALL_CATCH_EXCEPTION(0);
34310   }
34311
34312   jresult = (int)result;
34313   return jresult;
34314 }
34315
34316
34317 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() {
34318   int jresult ;
34319   int result;
34320
34321   {
34322     try {
34323       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
34324     } CALL_CATCH_EXCEPTION(0);
34325   }
34326
34327   jresult = (int)result;
34328   return jresult;
34329 }
34330
34331
34332 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() {
34333   int jresult ;
34334   int result;
34335
34336   {
34337     try {
34338       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
34339     } CALL_CATCH_EXCEPTION(0);
34340   }
34341
34342   jresult = (int)result;
34343   return jresult;
34344 }
34345
34346
34347 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() {
34348   int jresult ;
34349   int result;
34350
34351   {
34352     try {
34353       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
34354     } CALL_CATCH_EXCEPTION(0);
34355   }
34356
34357   jresult = (int)result;
34358   return jresult;
34359 }
34360
34361
34362 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() {
34363   int jresult ;
34364   int result;
34365
34366   {
34367     try {
34368       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
34369     } CALL_CATCH_EXCEPTION(0);
34370   }
34371
34372   jresult = (int)result;
34373   return jresult;
34374 }
34375
34376
34377 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() {
34378   int jresult ;
34379   int result;
34380
34381   {
34382     try {
34383       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
34384     } CALL_CATCH_EXCEPTION(0);
34385   }
34386
34387   jresult = (int)result;
34388   return jresult;
34389 }
34390
34391
34392 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
34393   int jresult ;
34394   int result;
34395
34396   {
34397     try {
34398       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
34399     } CALL_CATCH_EXCEPTION(0);
34400   }
34401
34402   jresult = (int)result;
34403   return jresult;
34404 }
34405
34406
34407 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() {
34408   int jresult ;
34409   int result;
34410
34411   {
34412     try {
34413       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
34414     } CALL_CATCH_EXCEPTION(0);
34415   }
34416
34417   jresult = (int)result;
34418   return jresult;
34419 }
34420
34421
34422 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() {
34423   int jresult ;
34424   int result;
34425
34426   {
34427     try {
34428       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
34429     } CALL_CATCH_EXCEPTION(0);
34430   }
34431
34432   jresult = (int)result;
34433   return jresult;
34434 }
34435
34436
34437 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() {
34438   int jresult ;
34439   int result;
34440
34441   {
34442     try {
34443       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
34444     } CALL_CATCH_EXCEPTION(0);
34445   }
34446
34447   jresult = (int)result;
34448   return jresult;
34449 }
34450
34451
34452 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() {
34453   int jresult ;
34454   int result;
34455
34456   {
34457     try {
34458       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
34459     } CALL_CATCH_EXCEPTION(0);
34460   }
34461
34462   jresult = (int)result;
34463   return jresult;
34464 }
34465
34466
34467 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() {
34468   int jresult ;
34469   int result;
34470
34471   {
34472     try {
34473       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
34474     } CALL_CATCH_EXCEPTION(0);
34475   }
34476
34477   jresult = (int)result;
34478   return jresult;
34479 }
34480
34481
34482 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() {
34483   int jresult ;
34484   int result;
34485
34486   {
34487     try {
34488       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
34489     } CALL_CATCH_EXCEPTION(0);
34490   }
34491
34492   jresult = (int)result;
34493   return jresult;
34494 }
34495
34496
34497 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() {
34498   int jresult ;
34499   int result;
34500
34501   {
34502     try {
34503       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
34504     } CALL_CATCH_EXCEPTION(0);
34505   }
34506
34507   jresult = (int)result;
34508   return jresult;
34509 }
34510
34511
34512 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() {
34513   int jresult ;
34514   int result;
34515
34516   {
34517     try {
34518       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
34519     } CALL_CATCH_EXCEPTION(0);
34520   }
34521
34522   jresult = (int)result;
34523   return jresult;
34524 }
34525
34526
34527 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() {
34528   int jresult ;
34529   int result;
34530
34531   {
34532     try {
34533       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
34534     } CALL_CATCH_EXCEPTION(0);
34535   }
34536
34537   jresult = (int)result;
34538   return jresult;
34539 }
34540
34541
34542 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
34543   int jresult ;
34544   int result;
34545
34546   {
34547     try {
34548       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
34549     } CALL_CATCH_EXCEPTION(0);
34550   }
34551
34552   jresult = (int)result;
34553   return jresult;
34554 }
34555
34556
34557 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_get() {
34558   int jresult ;
34559   int result;
34560
34561   {
34562     try {
34563       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
34564     } CALL_CATCH_EXCEPTION(0);
34565   }
34566
34567   jresult = (int)result;
34568   return jresult;
34569 }
34570
34571
34572 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() {
34573   int jresult ;
34574   int result;
34575
34576   {
34577     try {
34578       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
34579     } CALL_CATCH_EXCEPTION(0);
34580   }
34581
34582   jresult = (int)result;
34583   return jresult;
34584 }
34585
34586
34587 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() {
34588   int jresult ;
34589   int result;
34590
34591   {
34592     try {
34593       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
34594     } CALL_CATCH_EXCEPTION(0);
34595   }
34596
34597   jresult = (int)result;
34598   return jresult;
34599 }
34600
34601
34602 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() {
34603   int jresult ;
34604   int result;
34605
34606   {
34607     try {
34608       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
34609     } CALL_CATCH_EXCEPTION(0);
34610   }
34611
34612   jresult = (int)result;
34613   return jresult;
34614 }
34615
34616
34617 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() {
34618   int jresult ;
34619   int result;
34620
34621   {
34622     try {
34623       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
34624     } CALL_CATCH_EXCEPTION(0);
34625   }
34626
34627   jresult = (int)result;
34628   return jresult;
34629 }
34630
34631
34632 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() {
34633   int jresult ;
34634   int result;
34635
34636   {
34637     try {
34638       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
34639     } CALL_CATCH_EXCEPTION(0);
34640   }
34641
34642   jresult = (int)result;
34643   return jresult;
34644 }
34645
34646
34647 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() {
34648   int jresult ;
34649   int result;
34650
34651   {
34652     try {
34653       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
34654     } CALL_CATCH_EXCEPTION(0);
34655   }
34656
34657   jresult = (int)result;
34658   return jresult;
34659 }
34660
34661
34662 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() {
34663   int jresult ;
34664   int result;
34665
34666   {
34667     try {
34668       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
34669     } CALL_CATCH_EXCEPTION(0);
34670   }
34671
34672   jresult = (int)result;
34673   return jresult;
34674 }
34675
34676
34677 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() {
34678   int jresult ;
34679   int result;
34680
34681   {
34682     try {
34683       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
34684     } CALL_CATCH_EXCEPTION(0);
34685   }
34686
34687   jresult = (int)result;
34688   return jresult;
34689 }
34690
34691
34692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() {
34693   void * jresult ;
34694   Dali::Toolkit::Builder *result = 0 ;
34695
34696   {
34697     try {
34698       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
34699     } CALL_CATCH_EXCEPTION(0);
34700   }
34701
34702   jresult = (void *)result;
34703   return jresult;
34704 }
34705
34706
34707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() {
34708   void * jresult ;
34709   Dali::Toolkit::Builder result;
34710
34711   {
34712     try {
34713       result = Dali::Toolkit::Builder::New();
34714     } CALL_CATCH_EXCEPTION(0);
34715   }
34716
34717   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
34718   return jresult;
34719 }
34720
34721
34722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
34723   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
34724
34725   arg1 = (Dali::Toolkit::Builder *)jarg1;
34726   {
34727     try {
34728       delete arg1;
34729     } CALL_CATCH_EXCEPTION();
34730   }
34731
34732 }
34733
34734
34735 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
34736   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
34737   std::string *arg2 = 0 ;
34738   Dali::Toolkit::Builder::UIFormat arg3 ;
34739
34740   arg1 = (Dali::Toolkit::Builder *)jarg1;
34741   if (!jarg2) {
34742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
34743     return ;
34744   }
34745   std::string arg2_str(jarg2);
34746   arg2 = &arg2_str;
34747   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
34748   {
34749     try {
34750       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
34751     } CALL_CATCH_EXCEPTION();
34752   }
34753
34754
34755   //argout typemap for const std::string&
34756
34757 }
34758
34759
34760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
34761   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
34762   std::string *arg2 = 0 ;
34763
34764   arg1 = (Dali::Toolkit::Builder *)jarg1;
34765   if (!jarg2) {
34766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
34767     return ;
34768   }
34769   std::string arg2_str(jarg2);
34770   arg2 = &arg2_str;
34771   {
34772     try {
34773       (arg1)->LoadFromString((std::string const &)*arg2);
34774     } CALL_CATCH_EXCEPTION();
34775   }
34776
34777
34778   //argout typemap for const std::string&
34779
34780 }
34781
34782
34783 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) {
34784   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
34785   Dali::Property::Map *arg2 = 0 ;
34786
34787   arg1 = (Dali::Toolkit::Builder *)jarg1;
34788   arg2 = (Dali::Property::Map *)jarg2;
34789   if (!arg2) {
34790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
34791     return ;
34792   }
34793   {
34794     try {
34795       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
34796     } CALL_CATCH_EXCEPTION();
34797   }
34798
34799 }
34800
34801
34802 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
34803   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
34804   std::string *arg2 = 0 ;
34805   Dali::Property::Value *arg3 = 0 ;
34806
34807   arg1 = (Dali::Toolkit::Builder *)jarg1;
34808   if (!jarg2) {
34809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
34810     return ;
34811   }
34812   std::string arg2_str(jarg2);
34813   arg2 = &arg2_str;
34814   arg3 = (Dali::Property::Value *)jarg3;
34815   if (!arg3) {
34816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
34817     return ;
34818   }
34819   {
34820     try {
34821       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
34822     } CALL_CATCH_EXCEPTION();
34823   }
34824
34825
34826   //argout typemap for const std::string&
34827
34828 }
34829
34830
34831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
34832   void * jresult ;
34833   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
34834   Dali::Property::Map *result = 0 ;
34835
34836   arg1 = (Dali::Toolkit::Builder *)jarg1;
34837   {
34838     try {
34839       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
34840     } CALL_CATCH_EXCEPTION(0);
34841   }
34842
34843   jresult = (void *)result;
34844   return jresult;
34845 }
34846
34847
34848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) {
34849   void * jresult ;
34850   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
34851   std::string *arg2 = 0 ;
34852   Dali::Property::Value *result = 0 ;
34853
34854   arg1 = (Dali::Toolkit::Builder *)jarg1;
34855   if (!jarg2) {
34856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
34857     return 0;
34858   }
34859   std::string arg2_str(jarg2);
34860   arg2 = &arg2_str;
34861   {
34862     try {
34863       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
34864     } CALL_CATCH_EXCEPTION(0);
34865   }
34866
34867   jresult = (void *)result;
34868
34869   //argout typemap for const std::string&
34870
34871   return jresult;
34872 }
34873
34874
34875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
34876   void * jresult ;
34877   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
34878   std::string *arg2 = 0 ;
34879   Dali::Animation result;
34880
34881   arg1 = (Dali::Toolkit::Builder *)jarg1;
34882   if (!jarg2) {
34883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
34884     return 0;
34885   }
34886   std::string arg2_str(jarg2);
34887   arg2 = &arg2_str;
34888   {
34889     try {
34890       result = (arg1)->CreateAnimation((std::string const &)*arg2);
34891     } CALL_CATCH_EXCEPTION(0);
34892   }
34893
34894   jresult = new Dali::Animation((const Dali::Animation &)result);
34895
34896   //argout typemap for const std::string&
34897
34898   return jresult;
34899 }
34900
34901
34902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
34903   void * jresult ;
34904   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
34905   std::string *arg2 = 0 ;
34906   Dali::Property::Map *arg3 = 0 ;
34907   Dali::Animation result;
34908
34909   arg1 = (Dali::Toolkit::Builder *)jarg1;
34910   if (!jarg2) {
34911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
34912     return 0;
34913   }
34914   std::string arg2_str(jarg2);
34915   arg2 = &arg2_str;
34916   arg3 = (Dali::Property::Map *)jarg3;
34917   if (!arg3) {
34918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
34919     return 0;
34920   }
34921   {
34922     try {
34923       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
34924     } CALL_CATCH_EXCEPTION(0);
34925   }
34926
34927   jresult = new Dali::Animation((const Dali::Animation &)result);
34928
34929   //argout typemap for const std::string&
34930
34931   return jresult;
34932 }
34933
34934
34935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
34936   void * jresult ;
34937   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
34938   std::string *arg2 = 0 ;
34939   Dali::Actor arg3 ;
34940   Dali::Actor *argp3 ;
34941   Dali::Animation result;
34942
34943   arg1 = (Dali::Toolkit::Builder *)jarg1;
34944   if (!jarg2) {
34945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
34946     return 0;
34947   }
34948   std::string arg2_str(jarg2);
34949   arg2 = &arg2_str;
34950   argp3 = (Dali::Actor *)jarg3;
34951   if (!argp3) {
34952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
34953     return 0;
34954   }
34955   arg3 = *argp3;
34956   {
34957     try {
34958       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
34959     } CALL_CATCH_EXCEPTION(0);
34960   }
34961
34962   jresult = new Dali::Animation((const Dali::Animation &)result);
34963
34964   //argout typemap for const std::string&
34965
34966   return jresult;
34967 }
34968
34969
34970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
34971   void * jresult ;
34972   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
34973   std::string *arg2 = 0 ;
34974   Dali::Property::Map *arg3 = 0 ;
34975   Dali::Actor arg4 ;
34976   Dali::Actor *argp4 ;
34977   Dali::Animation result;
34978
34979   arg1 = (Dali::Toolkit::Builder *)jarg1;
34980   if (!jarg2) {
34981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
34982     return 0;
34983   }
34984   std::string arg2_str(jarg2);
34985   arg2 = &arg2_str;
34986   arg3 = (Dali::Property::Map *)jarg3;
34987   if (!arg3) {
34988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
34989     return 0;
34990   }
34991   argp4 = (Dali::Actor *)jarg4;
34992   if (!argp4) {
34993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
34994     return 0;
34995   }
34996   arg4 = *argp4;
34997   {
34998     try {
34999       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
35000     } CALL_CATCH_EXCEPTION(0);
35001   }
35002
35003   jresult = new Dali::Animation((const Dali::Animation &)result);
35004
35005   //argout typemap for const std::string&
35006
35007   return jresult;
35008 }
35009
35010
35011 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
35012   void * jresult ;
35013   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
35014   std::string *arg2 = 0 ;
35015   Dali::BaseHandle result;
35016
35017   arg1 = (Dali::Toolkit::Builder *)jarg1;
35018   if (!jarg2) {
35019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
35020     return 0;
35021   }
35022   std::string arg2_str(jarg2);
35023   arg2 = &arg2_str;
35024   {
35025     try {
35026       result = (arg1)->Create((std::string const &)*arg2);
35027     } CALL_CATCH_EXCEPTION(0);
35028   }
35029
35030   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
35031
35032   //argout typemap for const std::string&
35033
35034   return jresult;
35035 }
35036
35037
35038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
35039   void * jresult ;
35040   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
35041   std::string *arg2 = 0 ;
35042   Dali::Property::Map *arg3 = 0 ;
35043   Dali::BaseHandle result;
35044
35045   arg1 = (Dali::Toolkit::Builder *)jarg1;
35046   if (!jarg2) {
35047     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
35048     return 0;
35049   }
35050   std::string arg2_str(jarg2);
35051   arg2 = &arg2_str;
35052   arg3 = (Dali::Property::Map *)jarg3;
35053   if (!arg3) {
35054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
35055     return 0;
35056   }
35057   {
35058     try {
35059       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
35060     } CALL_CATCH_EXCEPTION(0);
35061   }
35062
35063   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
35064
35065   //argout typemap for const std::string&
35066
35067   return jresult;
35068 }
35069
35070
35071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
35072   void * jresult ;
35073   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
35074   std::string *arg2 = 0 ;
35075   Dali::BaseHandle result;
35076
35077   arg1 = (Dali::Toolkit::Builder *)jarg1;
35078   if (!jarg2) {
35079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
35080     return 0;
35081   }
35082   std::string arg2_str(jarg2);
35083   arg2 = &arg2_str;
35084   {
35085     try {
35086       result = (arg1)->CreateFromJson((std::string const &)*arg2);
35087     } CALL_CATCH_EXCEPTION(0);
35088   }
35089
35090   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
35091
35092   //argout typemap for const std::string&
35093
35094   return jresult;
35095 }
35096
35097
35098 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
35099   unsigned int jresult ;
35100   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
35101   std::string *arg2 = 0 ;
35102   Dali::Handle *arg3 = 0 ;
35103   bool result;
35104
35105   arg1 = (Dali::Toolkit::Builder *)jarg1;
35106   if (!jarg2) {
35107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
35108     return 0;
35109   }
35110   std::string arg2_str(jarg2);
35111   arg2 = &arg2_str;
35112   arg3 = (Dali::Handle *)jarg3;
35113   if (!arg3) {
35114     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
35115     return 0;
35116   }
35117   {
35118     try {
35119       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
35120     } CALL_CATCH_EXCEPTION(0);
35121   }
35122
35123   jresult = result;
35124
35125   //argout typemap for const std::string&
35126
35127   return jresult;
35128 }
35129
35130
35131 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
35132   unsigned int jresult ;
35133   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
35134   Dali::Handle *arg2 = 0 ;
35135   std::string *arg3 = 0 ;
35136   bool result;
35137
35138   arg1 = (Dali::Toolkit::Builder *)jarg1;
35139   arg2 = (Dali::Handle *)jarg2;
35140   if (!arg2) {
35141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
35142     return 0;
35143   }
35144   if (!jarg3) {
35145     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
35146     return 0;
35147   }
35148   std::string arg3_str(jarg3);
35149   arg3 = &arg3_str;
35150   {
35151     try {
35152       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
35153     } CALL_CATCH_EXCEPTION(0);
35154   }
35155
35156   jresult = result;
35157
35158   //argout typemap for const std::string&
35159
35160   return jresult;
35161 }
35162
35163
35164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
35165   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
35166   Dali::Actor arg2 ;
35167   Dali::Actor *argp2 ;
35168
35169   arg1 = (Dali::Toolkit::Builder *)jarg1;
35170   argp2 = (Dali::Actor *)jarg2;
35171   if (!argp2) {
35172     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
35173     return ;
35174   }
35175   arg2 = *argp2;
35176   {
35177     try {
35178       (arg1)->AddActors(arg2);
35179     } CALL_CATCH_EXCEPTION();
35180   }
35181
35182 }
35183
35184
35185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
35186   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
35187   std::string *arg2 = 0 ;
35188   Dali::Actor arg3 ;
35189   Dali::Actor *argp3 ;
35190
35191   arg1 = (Dali::Toolkit::Builder *)jarg1;
35192   if (!jarg2) {
35193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
35194     return ;
35195   }
35196   std::string arg2_str(jarg2);
35197   arg2 = &arg2_str;
35198   argp3 = (Dali::Actor *)jarg3;
35199   if (!argp3) {
35200     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
35201     return ;
35202   }
35203   arg3 = *argp3;
35204   {
35205     try {
35206       (arg1)->AddActors((std::string const &)*arg2,arg3);
35207     } CALL_CATCH_EXCEPTION();
35208   }
35209
35210
35211   //argout typemap for const std::string&
35212
35213 }
35214
35215
35216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
35217   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
35218   std::string *arg2 = 0 ;
35219
35220   arg1 = (Dali::Toolkit::Builder *)jarg1;
35221   if (!jarg2) {
35222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
35223     return ;
35224   }
35225   std::string arg2_str(jarg2);
35226   arg2 = &arg2_str;
35227   {
35228     try {
35229       (arg1)->CreateRenderTask((std::string const &)*arg2);
35230     } CALL_CATCH_EXCEPTION();
35231   }
35232
35233
35234   //argout typemap for const std::string&
35235
35236 }
35237
35238
35239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
35240   void * jresult ;
35241   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
35242   std::string *arg2 = 0 ;
35243   Dali::Path result;
35244
35245   arg1 = (Dali::Toolkit::Builder *)jarg1;
35246   if (!jarg2) {
35247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
35248     return 0;
35249   }
35250   std::string arg2_str(jarg2);
35251   arg2 = &arg2_str;
35252   {
35253     try {
35254       result = (arg1)->GetPath((std::string const &)*arg2);
35255     } CALL_CATCH_EXCEPTION(0);
35256   }
35257
35258   jresult = new Dali::Path((const Dali::Path &)result);
35259
35260   //argout typemap for const std::string&
35261
35262   return jresult;
35263 }
35264
35265
35266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
35267   void * jresult ;
35268   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
35269   std::string *arg2 = 0 ;
35270   Dali::PathConstrainer result;
35271
35272   arg1 = (Dali::Toolkit::Builder *)jarg1;
35273   if (!jarg2) {
35274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
35275     return 0;
35276   }
35277   std::string arg2_str(jarg2);
35278   arg2 = &arg2_str;
35279   {
35280     try {
35281       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
35282     } CALL_CATCH_EXCEPTION(0);
35283   }
35284
35285   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
35286
35287   //argout typemap for const std::string&
35288
35289   return jresult;
35290 }
35291
35292
35293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
35294   void * jresult ;
35295   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
35296   std::string *arg2 = 0 ;
35297   Dali::LinearConstrainer result;
35298
35299   arg1 = (Dali::Toolkit::Builder *)jarg1;
35300   if (!jarg2) {
35301     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
35302     return 0;
35303   }
35304   std::string arg2_str(jarg2);
35305   arg2 = &arg2_str;
35306   {
35307     try {
35308       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
35309     } CALL_CATCH_EXCEPTION(0);
35310   }
35311
35312   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
35313
35314   //argout typemap for const std::string&
35315
35316   return jresult;
35317 }
35318
35319
35320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
35321   void * jresult ;
35322   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
35323   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
35324
35325   arg1 = (Dali::Toolkit::Builder *)jarg1;
35326   {
35327     try {
35328       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
35329     } CALL_CATCH_EXCEPTION(0);
35330   }
35331
35332   jresult = (void *)result;
35333   return jresult;
35334 }
35335
35336
35337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
35338   void * jresult ;
35339   Dali::Toolkit::TransitionData *result = 0 ;
35340
35341   {
35342     try {
35343       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
35344     } CALL_CATCH_EXCEPTION(0);
35345   }
35346
35347   jresult = (void *)result;
35348   return jresult;
35349 }
35350
35351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
35352   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
35353
35354   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
35355   {
35356     try {
35357       delete arg1;
35358     } CALL_CATCH_EXCEPTION();
35359   }
35360
35361 }
35362
35363
35364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
35365   void * jresult ;
35366   Dali::Property::Map *arg1 = 0 ;
35367   Dali::Toolkit::TransitionData result;
35368
35369   arg1 = (Dali::Property::Map *)jarg1;
35370   if (!arg1) {
35371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
35372     return 0;
35373   }
35374   {
35375     try {
35376       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
35377     } CALL_CATCH_EXCEPTION(0);
35378   }
35379
35380   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
35381   return jresult;
35382 }
35383
35384
35385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
35386   void * jresult ;
35387   Dali::Property::Array *arg1 = 0 ;
35388   Dali::Toolkit::TransitionData result;
35389
35390   arg1 = (Dali::Property::Array *)jarg1;
35391   if (!arg1) {
35392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
35393     return 0;
35394   }
35395   {
35396     try {
35397       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
35398     } CALL_CATCH_EXCEPTION(0);
35399   }
35400
35401   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
35402   return jresult;
35403 }
35404
35405
35406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
35407   void * jresult ;
35408   Dali::BaseHandle arg1 ;
35409   Dali::BaseHandle *argp1 ;
35410   Dali::Toolkit::TransitionData result;
35411
35412   argp1 = (Dali::BaseHandle *)jarg1;
35413   if (!argp1) {
35414     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
35415     return 0;
35416   }
35417   arg1 = *argp1;
35418   {
35419     try {
35420       result = Dali::Toolkit::TransitionData::DownCast(arg1);
35421     } CALL_CATCH_EXCEPTION(0);
35422   }
35423
35424   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
35425   return jresult;
35426 }
35427
35428
35429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
35430   void * jresult ;
35431   Dali::Toolkit::TransitionData *arg1 = 0 ;
35432   Dali::Toolkit::TransitionData *result = 0 ;
35433
35434   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
35435   if (!arg1) {
35436     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
35437     return 0;
35438   }
35439   {
35440     try {
35441       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
35442     } CALL_CATCH_EXCEPTION(0);
35443   }
35444
35445   jresult = (void *)result;
35446   return jresult;
35447 }
35448
35449
35450 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
35451   void * jresult ;
35452   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
35453   Dali::Toolkit::TransitionData *arg2 = 0 ;
35454   Dali::Toolkit::TransitionData *result = 0 ;
35455
35456   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
35457   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
35458   if (!arg2) {
35459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
35460     return 0;
35461   }
35462   {
35463     try {
35464       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
35465     } CALL_CATCH_EXCEPTION(0);
35466   }
35467
35468   jresult = (void *)result;
35469   return jresult;
35470 }
35471
35472
35473 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
35474   unsigned long jresult ;
35475   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
35476   size_t result;
35477
35478   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
35479   {
35480     try {
35481       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
35482     } CALL_CATCH_EXCEPTION(0);
35483   }
35484
35485   jresult = (unsigned long)result;
35486   return jresult;
35487 }
35488
35489
35490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
35491   void * jresult ;
35492   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
35493   size_t arg2 ;
35494   Dali::Property::Map result;
35495
35496   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
35497   arg2 = (size_t)jarg2;
35498   {
35499     try {
35500       result = (arg1)->GetAnimatorAt(arg2);
35501     } CALL_CATCH_EXCEPTION(0);
35502   }
35503
35504   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
35505   return jresult;
35506 }
35507
35508
35509 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
35510   int jresult ;
35511   int result;
35512
35513   {
35514     try {
35515       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
35516     } CALL_CATCH_EXCEPTION(0);
35517   }
35518
35519   jresult = (int)result;
35520   return jresult;
35521 }
35522
35523
35524 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() {
35525   int jresult ;
35526   int result;
35527
35528   {
35529     try {
35530       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
35531     } CALL_CATCH_EXCEPTION(0);
35532   }
35533
35534   jresult = (int)result;
35535   return jresult;
35536 }
35537
35538
35539 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() {
35540   int jresult ;
35541   int result;
35542
35543   {
35544     try {
35545       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
35546     } CALL_CATCH_EXCEPTION(0);
35547   }
35548
35549   jresult = (int)result;
35550   return jresult;
35551 }
35552
35553
35554 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() {
35555   int jresult ;
35556   int result;
35557
35558   {
35559     try {
35560       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
35561     } CALL_CATCH_EXCEPTION(0);
35562   }
35563
35564   jresult = (int)result;
35565   return jresult;
35566 }
35567
35568
35569 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() {
35570   int jresult ;
35571   int result;
35572
35573   {
35574     try {
35575       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
35576     } CALL_CATCH_EXCEPTION(0);
35577   }
35578
35579   jresult = (int)result;
35580   return jresult;
35581 }
35582
35583
35584 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() {
35585   int jresult ;
35586   int result;
35587
35588   {
35589     try {
35590       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
35591     } CALL_CATCH_EXCEPTION(0);
35592   }
35593
35594   jresult = (int)result;
35595   return jresult;
35596 }
35597
35598
35599 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
35600   int jresult ;
35601   int result;
35602
35603   {
35604     try {
35605       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
35606     } CALL_CATCH_EXCEPTION(0);
35607   }
35608
35609   jresult = (int)result;
35610   return jresult;
35611 }
35612
35613
35614 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
35615   int jresult ;
35616   int result;
35617
35618   {
35619     try {
35620       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
35621     } CALL_CATCH_EXCEPTION(0);
35622   }
35623
35624   jresult = (int)result;
35625   return jresult;
35626 }
35627
35628
35629 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
35630   int jresult ;
35631   int result;
35632
35633   {
35634     try {
35635       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
35636     } CALL_CATCH_EXCEPTION(0);
35637   }
35638
35639   jresult = (int)result;
35640   return jresult;
35641 }
35642
35643
35644 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
35645   int jresult ;
35646   int result;
35647
35648   {
35649     try {
35650       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
35651     } CALL_CATCH_EXCEPTION(0);
35652   }
35653
35654   jresult = (int)result;
35655   return jresult;
35656 }
35657
35658
35659 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
35660   int jresult ;
35661   int result;
35662
35663   {
35664     try {
35665       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
35666     } CALL_CATCH_EXCEPTION(0);
35667   }
35668
35669   jresult = (int)result;
35670   return jresult;
35671 }
35672
35673
35674 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() {
35675   int jresult ;
35676   int result;
35677
35678   {
35679     try {
35680       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
35681     } CALL_CATCH_EXCEPTION(0);
35682   }
35683
35684   jresult = (int)result;
35685   return jresult;
35686 }
35687
35688
35689 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
35690   int jresult ;
35691   int result;
35692
35693   {
35694     try {
35695       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
35696     } CALL_CATCH_EXCEPTION(0);
35697   }
35698
35699   jresult = (int)result;
35700   return jresult;
35701 }
35702
35703
35704 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() {
35705   int jresult ;
35706   int result;
35707
35708   {
35709     try {
35710       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
35711     } CALL_CATCH_EXCEPTION(0);
35712   }
35713
35714   jresult = (int)result;
35715   return jresult;
35716 }
35717
35718
35719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
35720   void * jresult ;
35721   Dali::Toolkit::Control result;
35722
35723   {
35724     try {
35725       result = Dali::Toolkit::Internal::Control::New();
35726     } CALL_CATCH_EXCEPTION(0);
35727   }
35728
35729   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
35730   return jresult;
35731 }
35732
35733
35734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
35735   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
35736   std::string *arg2 = 0 ;
35737
35738   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
35739   if (!jarg2) {
35740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
35741     return ;
35742   }
35743   std::string arg2_str(jarg2);
35744   arg2 = &arg2_str;
35745   {
35746     try {
35747       (arg1)->SetStyleName((std::string const &)*arg2);
35748     } CALL_CATCH_EXCEPTION();
35749   }
35750
35751
35752   //argout typemap for const std::string&
35753
35754 }
35755
35756
35757 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
35758   char * jresult ;
35759   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
35760   std::string *result = 0 ;
35761
35762   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
35763   {
35764     try {
35765       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
35766     } CALL_CATCH_EXCEPTION(0);
35767   }
35768
35769   jresult = SWIG_csharp_string_callback(result->c_str());
35770   return jresult;
35771 }
35772
35773
35774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
35775   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
35776   Dali::Vector4 *arg2 = 0 ;
35777
35778   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
35779   arg2 = (Dali::Vector4 *)jarg2;
35780   if (!arg2) {
35781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
35782     return ;
35783   }
35784   {
35785     try {
35786       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
35787     } CALL_CATCH_EXCEPTION();
35788   }
35789
35790 }
35791
35792
35793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
35794   void * jresult ;
35795   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
35796   Dali::Vector4 result;
35797
35798   arg1 = (Dali::Handle *)jarg1;
35799   {
35800     try {
35801       Property::Map* resultMap = ((arg1)->GetProperty( Control::Property::BACKGROUND )).GetMap();
35802       if (resultMap)
35803       {
35804         Dali::Property::Value* type = resultMap->Find( Toolkit::Visual::Property::TYPE );
35805         if(type && type->Get<int>() == Visual::COLOR )
35806         {
35807           Dali::Property::Value* value = resultMap->Find( ColorVisual::Property::MIX_COLOR );
35808           if (value)
35809           {
35810             result = value->Get<Vector4>();
35811           }
35812         }
35813       }
35814     } CALL_CATCH_EXCEPTION(0);
35815   }
35816
35817   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
35818   return jresult;
35819 }
35820
35821
35822 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
35823   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
35824   Dali::Property::Map *arg2 = 0 ;
35825
35826   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
35827   arg2 = (Dali::Property::Map *)jarg2;
35828   if (!arg2) {
35829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
35830     return ;
35831   }
35832   {
35833     try {
35834       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
35835     } CALL_CATCH_EXCEPTION();
35836   }
35837
35838 }
35839
35840
35841 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
35842   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
35843
35844   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
35845   {
35846     try {
35847       (arg1)->ClearBackground();
35848     } CALL_CATCH_EXCEPTION();
35849   }
35850
35851 }
35852
35853
35854 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
35855   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
35856   Dali::Gesture::Type arg2 ;
35857
35858   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
35859   arg2 = (Dali::Gesture::Type)jarg2;
35860   {
35861     try {
35862       (arg1)->EnableGestureDetection(arg2);
35863     } CALL_CATCH_EXCEPTION();
35864   }
35865
35866 }
35867
35868
35869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
35870   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
35871   Dali::Gesture::Type arg2 ;
35872
35873   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
35874   arg2 = (Dali::Gesture::Type)jarg2;
35875   {
35876     try {
35877       (arg1)->DisableGestureDetection(arg2);
35878     } CALL_CATCH_EXCEPTION();
35879   }
35880
35881 }
35882
35883
35884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
35885   void * jresult ;
35886   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
35887   Dali::PinchGestureDetector result;
35888
35889   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
35890   {
35891     try {
35892       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
35893     } CALL_CATCH_EXCEPTION(0);
35894   }
35895
35896   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
35897   return jresult;
35898 }
35899
35900
35901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
35902   void * jresult ;
35903   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
35904   Dali::PanGestureDetector result;
35905
35906   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
35907   {
35908     try {
35909       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
35910     } CALL_CATCH_EXCEPTION(0);
35911   }
35912
35913   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
35914   return jresult;
35915 }
35916
35917
35918 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
35919   void * jresult ;
35920   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
35921   Dali::TapGestureDetector result;
35922
35923   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
35924   {
35925     try {
35926       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
35927     } CALL_CATCH_EXCEPTION(0);
35928   }
35929
35930   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
35931   return jresult;
35932 }
35933
35934
35935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
35936   void * jresult ;
35937   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
35938   Dali::LongPressGestureDetector result;
35939
35940   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
35941   {
35942     try {
35943       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
35944     } CALL_CATCH_EXCEPTION(0);
35945   }
35946
35947   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
35948   return jresult;
35949 }
35950
35951
35952 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, unsigned int jarg2) {
35953   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
35954   bool arg2 ;
35955
35956   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
35957   arg2 = jarg2 ? true : false;
35958   {
35959     try {
35960       (arg1)->SetKeyboardNavigationSupport(arg2);
35961     } CALL_CATCH_EXCEPTION();
35962   }
35963
35964 }
35965
35966
35967 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
35968   unsigned int jresult ;
35969   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
35970   bool result;
35971
35972   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
35973   {
35974     try {
35975       result = (bool)(arg1)->IsKeyboardNavigationSupported();
35976     } CALL_CATCH_EXCEPTION(0);
35977   }
35978
35979   jresult = result;
35980   return jresult;
35981 }
35982
35983
35984 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
35985   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
35986
35987   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
35988   {
35989     try {
35990       (arg1)->SetKeyInputFocus();
35991     } CALL_CATCH_EXCEPTION();
35992   }
35993
35994 }
35995
35996
35997 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
35998   unsigned int jresult ;
35999   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36000   bool result;
36001
36002   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36003   {
36004     try {
36005       result = (bool)(arg1)->HasKeyInputFocus();
36006     } CALL_CATCH_EXCEPTION(0);
36007   }
36008
36009   jresult = result;
36010   return jresult;
36011 }
36012
36013
36014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
36015   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36016
36017   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36018   {
36019     try {
36020       (arg1)->ClearKeyInputFocus();
36021     } CALL_CATCH_EXCEPTION();
36022   }
36023
36024 }
36025
36026
36027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, unsigned int jarg2) {
36028   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36029   bool arg2 ;
36030
36031   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36032   arg2 = jarg2 ? true : false;
36033   {
36034     try {
36035       (arg1)->SetAsKeyboardFocusGroup(arg2);
36036     } CALL_CATCH_EXCEPTION();
36037   }
36038
36039 }
36040
36041
36042 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
36043   unsigned int jresult ;
36044   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36045   bool result;
36046
36047   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36048   {
36049     try {
36050       result = (bool)(arg1)->IsKeyboardFocusGroup();
36051     } CALL_CATCH_EXCEPTION(0);
36052   }
36053
36054   jresult = result;
36055   return jresult;
36056 }
36057
36058
36059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
36060   void * jresult ;
36061   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36062   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
36063
36064   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36065   {
36066     try {
36067       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
36068     } CALL_CATCH_EXCEPTION(0);
36069   }
36070
36071   jresult = (void *)result;
36072   return jresult;
36073 }
36074
36075
36076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
36077   void * jresult ;
36078   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36079   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
36080
36081   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36082   {
36083     try {
36084       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
36085     } CALL_CATCH_EXCEPTION(0);
36086   }
36087
36088   jresult = (void *)result;
36089   return jresult;
36090 }
36091
36092
36093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
36094   void * jresult ;
36095   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36096   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
36097
36098   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36099   {
36100     try {
36101       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
36102     } CALL_CATCH_EXCEPTION(0);
36103   }
36104
36105   jresult = (void *)result;
36106   return jresult;
36107 }
36108
36109
36110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneConnection(void * jarg1, int jarg2) {
36111   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36112   int arg2 ;
36113   SwigDirector_ViewImpl *darg = 0;
36114
36115   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36116   arg2 = (int)jarg2;
36117   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36118   if(!darg) {
36119     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36120     return;
36121   }
36122   {
36123     try {
36124       if(darg) {
36125         (darg)->OnSceneConnection(arg2);
36126       }
36127     } CALL_CATCH_EXCEPTION();
36128   }
36129
36130 }
36131
36132
36133 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
36134   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36135   int arg2 ;
36136   SwigDirector_ViewImpl *darg = 0;
36137
36138   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36139   arg2 = (int)jarg2;
36140   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36141   if(!darg) {
36142     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36143     return;
36144   }
36145   {
36146     try {
36147       if(darg) {
36148         (darg)->OnSceneConnectionSwigPublic(arg2);
36149       }
36150     } CALL_CATCH_EXCEPTION();
36151   }
36152
36153 }
36154
36155
36156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneDisconnection(void * jarg1) {
36157   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36158   SwigDirector_ViewImpl *darg = 0;
36159
36160   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36161   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36162   if(!darg) {
36163     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36164     return;
36165   }
36166   {
36167     try {
36168       if(darg) {
36169         (darg)->OnSceneDisconnection();
36170       }
36171     } CALL_CATCH_EXCEPTION();
36172   }
36173
36174 }
36175
36176
36177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneDisconnectionSwigExplicitViewImpl(void * jarg1) {
36178   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36179   SwigDirector_ViewImpl *darg = 0;
36180
36181   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36182   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36183   if(!darg) {
36184     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36185     return;
36186   }
36187   {
36188     try {
36189       if(darg) {
36190         (darg)->OnSceneDisconnectionSwigPublic();
36191       }
36192     } CALL_CATCH_EXCEPTION();
36193   }
36194
36195 }
36196
36197
36198 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
36199   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36200   Dali::Actor *arg2 = 0 ;
36201   SwigDirector_ViewImpl *darg = 0;
36202
36203   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36204   arg2 = (Dali::Actor *)jarg2;
36205   if (!arg2) {
36206     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
36207     return ;
36208   }
36209   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36210   if(!darg) {
36211     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36212     return;
36213   }
36214   {
36215     try {
36216       if(darg) {
36217         (darg)->OnChildAdd(*arg2);
36218       }
36219     } CALL_CATCH_EXCEPTION();
36220   }
36221
36222 }
36223
36224
36225 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
36226   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36227   Dali::Actor *arg2 = 0 ;
36228   SwigDirector_ViewImpl *darg = 0;
36229
36230   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36231   arg2 = (Dali::Actor *)jarg2;
36232   if (!arg2) {
36233     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
36234     return ;
36235   }
36236   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36237   if(!darg) {
36238     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36239     return;
36240   }
36241   {
36242     try {
36243       if(darg) {
36244           (darg)->OnChildAddSwigPublic(*arg2);
36245       }
36246     } CALL_CATCH_EXCEPTION();
36247   }
36248
36249 }
36250
36251
36252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
36253   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36254   Dali::Actor *arg2 = 0 ;
36255   SwigDirector_ViewImpl *darg = 0;
36256
36257   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36258   arg2 = (Dali::Actor *)jarg2;
36259   if (!arg2) {
36260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
36261     return ;
36262   }
36263   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36264   if(!darg) {
36265     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36266     return;
36267   }
36268   {
36269     try {
36270       if(darg) {
36271         (darg)->OnChildRemove(*arg2);
36272       }
36273     } CALL_CATCH_EXCEPTION();
36274   }
36275
36276 }
36277
36278
36279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
36280   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36281   Dali::Actor *arg2 = 0 ;
36282   SwigDirector_ViewImpl *darg = 0;
36283
36284   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36285   arg2 = (Dali::Actor *)jarg2;
36286   if (!arg2) {
36287     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
36288     return ;
36289   }
36290   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36291   if(!darg) {
36292     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36293     return;
36294   }
36295   {
36296     try {
36297       if(darg) {
36298         (darg)->OnChildRemoveSwigPublic(*arg2);
36299       }
36300     } CALL_CATCH_EXCEPTION();
36301   }
36302
36303 }
36304
36305
36306 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
36307   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36308   Dali::Property::Index arg2 ;
36309   Dali::Property::Value arg3 ;
36310   Dali::Property::Value *argp3 ;
36311   SwigDirector_ViewImpl *darg = 0;
36312
36313   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36314   arg2 = (Dali::Property::Index)jarg2;
36315   argp3 = (Dali::Property::Value *)jarg3;
36316   if (!argp3) {
36317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
36318     return ;
36319   }
36320   arg3 = *argp3;
36321   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36322   if (!darg) {
36323     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36324     return;
36325   }
36326   {
36327     try {
36328       (darg)->OnPropertySet(arg2,arg3);
36329     } CALL_CATCH_EXCEPTION();
36330   }
36331
36332 }
36333
36334
36335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
36336   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36337   Dali::Vector3 *arg2 = 0 ;
36338   SwigDirector_ViewImpl *darg = 0;
36339
36340   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36341   arg2 = (Dali::Vector3 *)jarg2;
36342   if (!arg2) {
36343     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
36344     return ;
36345   }
36346   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36347   if (!darg) {
36348     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36349     return;
36350   }
36351   {
36352     try {
36353       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
36354     } CALL_CATCH_EXCEPTION();
36355   }
36356
36357 }
36358
36359
36360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
36361   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36362   Dali::Vector3 *arg2 = 0 ;
36363   SwigDirector_ViewImpl *darg = 0;
36364
36365   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36366   arg2 = (Dali::Vector3 *)jarg2;
36367   if (!arg2) {
36368     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
36369     return ;
36370   }
36371   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36372   if (!darg) {
36373     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36374     return;
36375   }
36376   {
36377     try {
36378       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
36379     } CALL_CATCH_EXCEPTION();
36380   }
36381
36382 }
36383
36384
36385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
36386   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36387   Dali::Animation *arg2 = 0 ;
36388   Dali::Vector3 *arg3 = 0 ;
36389   SwigDirector_ViewImpl *darg = 0;
36390
36391   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36392   arg2 = (Dali::Animation *)jarg2;
36393   if (!arg2) {
36394     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
36395     return ;
36396   }
36397   arg3 = (Dali::Vector3 *)jarg3;
36398   if (!arg3) {
36399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
36400     return ;
36401   }
36402   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36403   if (!darg) {
36404     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36405     return;
36406   }
36407   {
36408     try {
36409       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
36410     } CALL_CATCH_EXCEPTION();
36411   }
36412
36413 }
36414
36415
36416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
36417   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36418   Dali::Animation *arg2 = 0 ;
36419   Dali::Vector3 *arg3 = 0 ;
36420   SwigDirector_ViewImpl *darg = 0;
36421
36422   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36423   arg2 = (Dali::Animation *)jarg2;
36424   if (!arg2) {
36425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
36426     return ;
36427   }
36428   arg3 = (Dali::Vector3 *)jarg3;
36429   if (!arg3) {
36430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
36431     return ;
36432   }
36433   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36434   if (!darg) {
36435     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36436     return;
36437   }
36438   {
36439     try {
36440       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
36441     } CALL_CATCH_EXCEPTION();
36442   }
36443 }
36444
36445
36446 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEvent(void * jarg1, void * jarg2) {
36447   unsigned int jresult ;
36448   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36449   Dali::HoverEvent *arg2 = 0 ;
36450   SwigDirector_ViewImpl *darg = 0;
36451   bool result;
36452
36453   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36454   arg2 = (Dali::HoverEvent *)jarg2;
36455   if (!arg2) {
36456     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
36457     return 0;
36458   }
36459   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36460   if (!darg) {
36461     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36462     return 0;
36463   }
36464   {
36465     try {
36466       result = (bool)(darg)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
36467     } CALL_CATCH_EXCEPTION(0);
36468   }
36469
36470   jresult = result;
36471   return jresult;
36472 }
36473
36474
36475 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
36476   unsigned int jresult ;
36477   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36478   Dali::HoverEvent *arg2 = 0 ;
36479   SwigDirector_ViewImpl *darg = 0;
36480   bool result;
36481
36482   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36483   arg2 = (Dali::HoverEvent *)jarg2;
36484   if (!arg2) {
36485     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
36486     return 0;
36487   }
36488   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36489   if (!darg) {
36490     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36491     return 0;
36492   }
36493   {
36494     try {
36495       result = (bool)(darg)->OnHoverEventSwigPublic((Dali::HoverEvent const &)*arg2);
36496     } CALL_CATCH_EXCEPTION(0);
36497   }
36498
36499   jresult = result;
36500   return jresult;
36501 }
36502
36503
36504 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
36505   unsigned int jresult ;
36506   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36507   Dali::KeyEvent *arg2 = 0 ;
36508   SwigDirector_ViewImpl *darg = 0;
36509   bool result;
36510
36511   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36512   arg2 = (Dali::KeyEvent *)jarg2;
36513   if (!arg2) {
36514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
36515     return 0;
36516   }
36517   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36518   if (!darg) {
36519     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36520     return 0;
36521   }
36522   {
36523     try {
36524       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
36525     } CALL_CATCH_EXCEPTION(0);
36526   }
36527
36528   jresult = result;
36529   return jresult;
36530 }
36531
36532
36533 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
36534   unsigned int jresult ;
36535   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36536   Dali::KeyEvent *arg2 = 0 ;
36537   SwigDirector_ViewImpl *darg = 0;
36538   bool result;
36539
36540   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36541   arg2 = (Dali::KeyEvent *)jarg2;
36542   if (!arg2) {
36543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
36544     return 0;
36545   }
36546   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36547   if (!darg) {
36548     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36549     return 0;
36550   }
36551   {
36552     try {
36553       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
36554     } CALL_CATCH_EXCEPTION(0);
36555   }
36556
36557   jresult = result;
36558   return jresult;
36559 }
36560
36561
36562 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEvent(void * jarg1, void * jarg2) {
36563   unsigned int jresult ;
36564   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36565   Dali::WheelEvent *arg2 = 0 ;
36566   SwigDirector_ViewImpl *darg = 0;
36567   bool result;
36568
36569   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36570   arg2 = (Dali::WheelEvent *)jarg2;
36571   if (!arg2) {
36572     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
36573     return 0;
36574   }
36575   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36576   if (!darg) {
36577     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36578     return 0;
36579   }
36580   {
36581     try {
36582       result = (bool)(darg)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
36583     } CALL_CATCH_EXCEPTION(0);
36584   }
36585
36586   jresult = result;
36587   return jresult;
36588 }
36589
36590
36591 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
36592   unsigned int jresult ;
36593   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36594   Dali::WheelEvent *arg2 = 0 ;
36595   SwigDirector_ViewImpl *darg = 0;
36596   bool result;
36597
36598   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36599   arg2 = (Dali::WheelEvent *)jarg2;
36600   if (!arg2) {
36601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
36602     return 0;
36603   }
36604   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36605   if (!darg) {
36606     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36607     return 0;
36608   }
36609   {
36610     try {
36611       result = (bool)(darg)->OnWheelEventSwigPublic((Dali::WheelEvent const &)*arg2);
36612     } CALL_CATCH_EXCEPTION(0);
36613   }
36614
36615   jresult = result;
36616   return jresult;
36617 }
36618
36619
36620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
36621   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36622   Dali::Vector2 *arg2 = 0 ;
36623   Dali::RelayoutContainer *arg3 = 0 ;
36624   SwigDirector_ViewImpl *darg = 0;
36625
36626   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36627   arg2 = (Dali::Vector2 *)jarg2;
36628   if (!arg2) {
36629     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36630     return ;
36631   }
36632   arg3 = (Dali::RelayoutContainer *)jarg3;
36633   if (!arg3) {
36634     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
36635     return ;
36636   }
36637   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36638   if (!darg) {
36639     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36640     return;
36641   }
36642   {
36643     try {
36644       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
36645     } CALL_CATCH_EXCEPTION();
36646   }
36647
36648 }
36649
36650
36651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
36652   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36653   Dali::Vector2 *arg2 = 0 ;
36654   Dali::RelayoutContainer *arg3 = 0 ;
36655   SwigDirector_ViewImpl *darg = 0;
36656
36657   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36658   arg2 = (Dali::Vector2 *)jarg2;
36659   if (!arg2) {
36660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36661     return ;
36662   }
36663   arg3 = (Dali::RelayoutContainer *)jarg3;
36664   if (!arg3) {
36665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
36666     return ;
36667   }
36668   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36669   if (!darg) {
36670     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36671     return;
36672   }
36673   {
36674     try {
36675       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
36676     } CALL_CATCH_EXCEPTION();
36677   }
36678
36679 }
36680
36681
36682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
36683   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36684   Dali::ResizePolicy::Type arg2 ;
36685   Dali::Dimension::Type arg3 ;
36686   SwigDirector_ViewImpl *darg = 0;
36687
36688   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36689   arg2 = (Dali::ResizePolicy::Type)jarg2;
36690   arg3 = (Dali::Dimension::Type)jarg3;
36691   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36692   if (!darg) {
36693     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36694     return;
36695   }
36696   {
36697     try {
36698       (darg)->OnSetResizePolicy(arg2,arg3);
36699     } CALL_CATCH_EXCEPTION();
36700   }
36701
36702 }
36703
36704
36705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
36706   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36707   Dali::ResizePolicy::Type arg2 ;
36708   Dali::Dimension::Type arg3 ;
36709   SwigDirector_ViewImpl *darg = 0;
36710
36711   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36712   arg2 = (Dali::ResizePolicy::Type)jarg2;
36713   arg3 = (Dali::Dimension::Type)jarg3;
36714   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36715   if (!darg) {
36716     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36717     return;
36718   }
36719   {
36720     try {
36721       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
36722     } CALL_CATCH_EXCEPTION();
36723   }
36724
36725 }
36726
36727
36728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
36729   void * jresult ;
36730   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36731   SwigDirector_ViewImpl *darg = 0;
36732   Dali::Vector3 result;
36733
36734   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36735   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36736   if (!darg) {
36737     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36738     return 0;
36739   }
36740   {
36741     try {
36742       result = (darg)->GetNaturalSize();
36743     } CALL_CATCH_EXCEPTION(0);
36744   }
36745
36746   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
36747   return jresult;
36748 }
36749
36750
36751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
36752   void * jresult ;
36753   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36754   SwigDirector_ViewImpl *darg = 0;
36755   Dali::Vector3 result;
36756
36757   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36758   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36759   if (!darg) {
36760     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36761     return 0;
36762   }
36763   {
36764     try {
36765       result = (darg)->GetNaturalSizeSwigPublic();
36766     } CALL_CATCH_EXCEPTION(0);
36767   }
36768
36769   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
36770   return jresult;
36771 }
36772
36773
36774 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
36775   float jresult ;
36776   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36777   Dali::Actor *arg2 = 0 ;
36778   Dali::Dimension::Type arg3 ;
36779   SwigDirector_ViewImpl *darg = 0;
36780   float result;
36781
36782   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36783   arg2 = (Dali::Actor *)jarg2;
36784   if (!arg2) {
36785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
36786     return 0;
36787   }
36788   arg3 = (Dali::Dimension::Type)jarg3;
36789   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36790   if (!darg) {
36791     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36792     return 0;
36793   }
36794   {
36795     try {
36796       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
36797     } CALL_CATCH_EXCEPTION(0);
36798   }
36799
36800   jresult = result;
36801   return jresult;
36802 }
36803
36804
36805 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
36806   float jresult ;
36807   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36808   Dali::Actor *arg2 = 0 ;
36809   Dali::Dimension::Type arg3 ;
36810   SwigDirector_ViewImpl *darg = 0;
36811   float result;
36812
36813   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36814   arg2 = (Dali::Actor *)jarg2;
36815   if (!arg2) {
36816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
36817     return 0;
36818   }
36819   arg3 = (Dali::Dimension::Type)jarg3;
36820   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36821   if (!darg) {
36822     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36823     return 0;
36824   }
36825   {
36826     try {
36827       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
36828     } CALL_CATCH_EXCEPTION(0);
36829   }
36830
36831   jresult = result;
36832   return jresult;
36833 }
36834
36835
36836 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
36837   float jresult ;
36838   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36839   float arg2 ;
36840   SwigDirector_ViewImpl *darg = 0;
36841   float result;
36842
36843   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36844   arg2 = (float)jarg2;
36845   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36846   if (!darg) {
36847     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36848     return 0;
36849   }
36850   {
36851     try {
36852       result = (float)(darg)->GetHeightForWidth(arg2);
36853     } CALL_CATCH_EXCEPTION(0);
36854   }
36855
36856   jresult = result;
36857   return jresult;
36858 }
36859
36860
36861 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
36862   float jresult ;
36863   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36864   float arg2 ;
36865   SwigDirector_ViewImpl *darg = 0;
36866   float result;
36867
36868   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36869   arg2 = (float)jarg2;
36870   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36871   if (!darg) {
36872     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36873     return 0;
36874   }
36875   {
36876     try {
36877       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
36878     } CALL_CATCH_EXCEPTION(0);
36879   }
36880
36881   jresult = result;
36882   return jresult;
36883 }
36884
36885
36886 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
36887   float jresult ;
36888   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36889   float arg2 ;
36890   SwigDirector_ViewImpl *darg = 0;
36891   float result;
36892
36893   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36894   arg2 = (float)jarg2;
36895   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36896   if (!darg) {
36897     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36898     return 0;
36899   }
36900   {
36901     try {
36902       result = (float)(darg)->GetWidthForHeight(arg2);
36903     } CALL_CATCH_EXCEPTION(0);
36904   }
36905
36906   jresult = result;
36907   return jresult;
36908 }
36909
36910
36911 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
36912   float jresult ;
36913   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36914   float arg2 ;
36915   SwigDirector_ViewImpl *darg = 0;
36916   float result;
36917
36918   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36919   arg2 = (float)jarg2;
36920   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36921   if (!darg) {
36922     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36923     return 0;
36924   }
36925   {
36926     try {
36927       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
36928     } CALL_CATCH_EXCEPTION(0);
36929   }
36930
36931   jresult = result;
36932   return jresult;
36933 }
36934
36935
36936 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
36937   unsigned int jresult ;
36938   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36939   Dali::Dimension::Type arg2 ;
36940   SwigDirector_ViewImpl *darg = 0;
36941   bool result;
36942
36943   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36944   arg2 = (Dali::Dimension::Type)jarg2;
36945   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36946   if (!darg) {
36947     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36948     return 0;
36949   }
36950   {
36951     try {
36952       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
36953     } CALL_CATCH_EXCEPTION(0);
36954   }
36955
36956   jresult = result;
36957   return jresult;
36958 }
36959
36960
36961 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
36962   unsigned int jresult ;
36963   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36964   Dali::Dimension::Type arg2 ;
36965   SwigDirector_ViewImpl *darg = 0;
36966   bool result;
36967
36968   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36969   arg2 = (Dali::Dimension::Type)jarg2;
36970   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36971   if (!darg) {
36972     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36973     return 0;
36974   }
36975   {
36976     try {
36977       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
36978     } CALL_CATCH_EXCEPTION(0);
36979   }
36980
36981   jresult = result;
36982   return jresult;
36983 }
36984
36985
36986 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
36987   unsigned int jresult ;
36988   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36989   SwigDirector_ViewImpl *darg = 0;
36990   bool result;
36991
36992   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36993   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36994   if (!darg) {
36995     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36996     return 0;
36997   }
36998   {
36999     try {
37000       result = (bool)(darg)->RelayoutDependentOnChildren();
37001     } CALL_CATCH_EXCEPTION(0);
37002   }
37003
37004   jresult = result;
37005   return jresult;
37006 }
37007
37008
37009 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
37010   unsigned int jresult ;
37011   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37012   SwigDirector_ViewImpl *darg = 0;
37013   bool result;
37014
37015   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37016   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
37017   if (!darg) {
37018     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
37019     return 0;
37020   }
37021   {
37022     try {
37023       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
37024     } CALL_CATCH_EXCEPTION(0);
37025   }
37026
37027   jresult = result;
37028   return jresult;
37029 }
37030
37031
37032 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
37033   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37034   Dali::Dimension::Type arg2 ;
37035   SwigDirector_ViewImpl *darg = 0;
37036
37037   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37038   arg2 = (Dali::Dimension::Type)jarg2;
37039   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
37040   if (!darg) {
37041     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
37042     return;
37043   }
37044   {
37045     try {
37046       (darg)->OnCalculateRelayoutSize(arg2);
37047     } CALL_CATCH_EXCEPTION();
37048   }
37049
37050 }
37051
37052
37053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
37054   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37055   Dali::Dimension::Type arg2 ;
37056   SwigDirector_ViewImpl *darg = 0;
37057
37058   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37059   arg2 = (Dali::Dimension::Type)jarg2;
37060   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
37061   if (!darg) {
37062     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
37063     return;
37064   }
37065   {
37066     try {
37067       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
37068     } CALL_CATCH_EXCEPTION();
37069   }
37070
37071 }
37072
37073
37074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
37075   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37076   float arg2 ;
37077   Dali::Dimension::Type arg3 ;
37078   SwigDirector_ViewImpl *darg = 0;
37079
37080   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37081   arg2 = (float)jarg2;
37082   arg3 = (Dali::Dimension::Type)jarg3;
37083   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
37084   if (!darg) {
37085     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
37086     return;
37087   }
37088   {
37089     try {
37090       (darg)->OnLayoutNegotiated(arg2,arg3);
37091     } CALL_CATCH_EXCEPTION();
37092   }
37093
37094 }
37095
37096
37097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
37098   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37099   float arg2 ;
37100   Dali::Dimension::Type arg3 ;
37101   SwigDirector_ViewImpl *darg = 0;
37102
37103   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37104   arg2 = (float)jarg2;
37105   arg3 = (Dali::Dimension::Type)jarg3;
37106   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
37107   if (!darg) {
37108     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
37109     return;
37110   }
37111   {
37112     try {
37113       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
37114     } CALL_CATCH_EXCEPTION();
37115   }
37116
37117 }
37118
37119
37120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
37121   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37122
37123   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37124   {
37125     try {
37126       (arg1)->OnInitialize();
37127     } CALL_CATCH_EXCEPTION();
37128   }
37129
37130 }
37131
37132
37133 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
37134   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37135
37136   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37137   {
37138     try {
37139       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
37140     } CALL_CATCH_EXCEPTION();
37141   }
37142
37143 }
37144
37145
37146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
37147   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37148   Dali::Toolkit::StyleManager arg2 ;
37149   Dali::StyleChange::Type arg3 ;
37150   Dali::Toolkit::StyleManager *argp2 ;
37151
37152   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37153   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
37154   if (!argp2) {
37155     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
37156     return ;
37157   }
37158   arg2 = *argp2;
37159   arg3 = (Dali::StyleChange::Type)jarg3;
37160   {
37161     try {
37162       (arg1)->OnStyleChange(arg2,arg3);
37163     } CALL_CATCH_EXCEPTION();
37164   }
37165
37166 }
37167
37168
37169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
37170   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37171   Dali::Toolkit::StyleManager arg2 ;
37172   Dali::StyleChange::Type arg3 ;
37173   Dali::Toolkit::StyleManager *argp2 ;
37174
37175   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37176   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
37177   if (!argp2) {
37178     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
37179     return ;
37180   }
37181   arg2 = *argp2;
37182   arg3 = (Dali::StyleChange::Type)jarg3;
37183   {
37184     try {
37185       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
37186     } CALL_CATCH_EXCEPTION();
37187   }
37188
37189 }
37190
37191
37192 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
37193   unsigned int jresult ;
37194   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37195   bool result;
37196
37197   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37198   {
37199     try {
37200       result = (bool)(arg1)->OnAccessibilityActivated();
37201     } CALL_CATCH_EXCEPTION(0);
37202   }
37203
37204   jresult = result;
37205   return jresult;
37206 }
37207
37208
37209 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
37210   unsigned int jresult ;
37211   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37212   bool result;
37213
37214   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37215   {
37216     try {
37217       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
37218     } CALL_CATCH_EXCEPTION(0);
37219   }
37220
37221   jresult = result;
37222   return jresult;
37223 }
37224
37225
37226 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
37227   unsigned int jresult ;
37228   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37229   Dali::PanGesture arg2 ;
37230   Dali::PanGesture *argp2 ;
37231   bool result;
37232
37233   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37234   argp2 = (Dali::PanGesture *)jarg2;
37235   if (!argp2) {
37236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
37237     return 0;
37238   }
37239   arg2 = *argp2;
37240   {
37241     try {
37242       result = (bool)(arg1)->OnAccessibilityPan(arg2);
37243     } CALL_CATCH_EXCEPTION(0);
37244   }
37245
37246   jresult = result;
37247   return jresult;
37248 }
37249
37250
37251 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
37252   unsigned int jresult ;
37253   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37254   Dali::PanGesture arg2 ;
37255   Dali::PanGesture *argp2 ;
37256   bool result;
37257
37258   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37259   argp2 = (Dali::PanGesture *)jarg2;
37260   if (!argp2) {
37261     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
37262     return 0;
37263   }
37264   arg2 = *argp2;
37265   {
37266     try {
37267       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
37268     } CALL_CATCH_EXCEPTION(0);
37269   }
37270
37271   jresult = result;
37272   return jresult;
37273 }
37274
37275 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, unsigned int jarg2) {
37276   unsigned int jresult ;
37277   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37278   bool arg2 ;
37279   bool result;
37280
37281   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37282   arg2 = jarg2 ? true : false;
37283   {
37284     try {
37285       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
37286     } CALL_CATCH_EXCEPTION(0);
37287   }
37288
37289   jresult = result;
37290   return jresult;
37291 }
37292
37293
37294 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, unsigned int jarg2) {
37295   unsigned int jresult ;
37296   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37297   bool arg2 ;
37298   bool result;
37299
37300   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37301   arg2 = jarg2 ? true : false;
37302   {
37303     try {
37304       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
37305     } CALL_CATCH_EXCEPTION(0);
37306   }
37307
37308   jresult = result;
37309   return jresult;
37310 }
37311
37312
37313 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
37314   unsigned int jresult ;
37315   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37316   bool result;
37317
37318   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37319   {
37320     try {
37321       result = (bool)(arg1)->OnAccessibilityZoom();
37322     } CALL_CATCH_EXCEPTION(0);
37323   }
37324
37325   jresult = result;
37326   return jresult;
37327 }
37328
37329
37330 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
37331   unsigned int jresult ;
37332   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37333   bool result;
37334
37335   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37336   {
37337     try {
37338       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
37339     } CALL_CATCH_EXCEPTION(0);
37340   }
37341
37342   jresult = result;
37343   return jresult;
37344 }
37345
37346
37347 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
37348   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37349
37350   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37351   {
37352     try {
37353       (arg1)->OnKeyInputFocusGained();
37354     } CALL_CATCH_EXCEPTION();
37355   }
37356
37357 }
37358
37359
37360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
37361   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37362
37363   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37364   {
37365     try {
37366       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
37367     } CALL_CATCH_EXCEPTION();
37368   }
37369
37370 }
37371
37372
37373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
37374   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37375
37376   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37377   {
37378     try {
37379       (arg1)->OnKeyInputFocusLost();
37380     } CALL_CATCH_EXCEPTION();
37381   }
37382
37383 }
37384
37385
37386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
37387   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37388
37389   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37390   {
37391     try {
37392       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
37393     } CALL_CATCH_EXCEPTION();
37394   }
37395
37396 }
37397
37398
37399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
37400   void * jresult ;
37401   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37402   Dali::Actor arg2 ;
37403   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
37404   bool arg4 ;
37405   Dali::Actor *argp2 ;
37406   Dali::Actor result;
37407
37408   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37409   argp2 = (Dali::Actor *)jarg2;
37410   if (!argp2) {
37411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
37412     return 0;
37413   }
37414   arg2 = *argp2;
37415   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
37416   arg4 = jarg4 ? true : false;
37417   {
37418     try {
37419       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
37420     } CALL_CATCH_EXCEPTION(0);
37421   }
37422
37423   jresult = new Dali::Actor((const Dali::Actor &)result);
37424   return jresult;
37425 }
37426
37427
37428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
37429   void * jresult ;
37430   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37431   Dali::Actor arg2 ;
37432   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
37433   bool arg4 ;
37434   Dali::Actor *argp2 ;
37435   Dali::Actor result;
37436
37437   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37438   argp2 = (Dali::Actor *)jarg2;
37439   if (!argp2) {
37440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
37441     return 0;
37442   }
37443   arg2 = *argp2;
37444   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
37445   arg4 = jarg4 ? true : false;
37446   {
37447     try {
37448       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
37449     } CALL_CATCH_EXCEPTION(0);
37450   }
37451
37452   jresult = new Dali::Actor((const Dali::Actor &)result);
37453   return jresult;
37454 }
37455
37456
37457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
37458   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37459   Dali::Actor arg2 ;
37460   Dali::Actor *argp2 ;
37461
37462   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37463   argp2 = (Dali::Actor *)jarg2;
37464   if (!argp2) {
37465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
37466     return ;
37467   }
37468   arg2 = *argp2;
37469   {
37470     try {
37471       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
37472     } CALL_CATCH_EXCEPTION();
37473   }
37474
37475 }
37476
37477
37478 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
37479   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37480   Dali::Actor arg2 ;
37481   Dali::Actor *argp2 ;
37482
37483   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37484   argp2 = (Dali::Actor *)jarg2;
37485   if (!argp2) {
37486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
37487     return ;
37488   }
37489   arg2 = *argp2;
37490   {
37491     try {
37492       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
37493     } CALL_CATCH_EXCEPTION();
37494   }
37495
37496 }
37497
37498
37499 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
37500   unsigned int jresult ;
37501   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37502   bool result;
37503
37504   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37505   {
37506     try {
37507       result = (bool)(arg1)->OnKeyboardEnter();
37508     } CALL_CATCH_EXCEPTION(0);
37509   }
37510
37511   jresult = result;
37512   return jresult;
37513 }
37514
37515
37516 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
37517   unsigned int jresult ;
37518   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37519   bool result;
37520
37521   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37522   {
37523     try {
37524       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
37525     } CALL_CATCH_EXCEPTION(0);
37526   }
37527
37528   jresult = result;
37529   return jresult;
37530 }
37531
37532
37533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
37534   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37535   Dali::PinchGesture *arg2 = 0 ;
37536
37537   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37538   arg2 = (Dali::PinchGesture *)jarg2;
37539   if (!arg2) {
37540     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
37541     return ;
37542   }
37543   {
37544     try {
37545       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
37546     } CALL_CATCH_EXCEPTION();
37547   }
37548
37549 }
37550
37551
37552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
37553   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37554   Dali::PinchGesture *arg2 = 0 ;
37555
37556   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37557   arg2 = (Dali::PinchGesture *)jarg2;
37558   if (!arg2) {
37559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
37560     return ;
37561   }
37562   {
37563     try {
37564       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
37565     } CALL_CATCH_EXCEPTION();
37566   }
37567
37568 }
37569
37570
37571 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
37572   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37573   Dali::PanGesture *arg2 = 0 ;
37574
37575   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37576   arg2 = (Dali::PanGesture *)jarg2;
37577   if (!arg2) {
37578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
37579     return ;
37580   }
37581   {
37582     try {
37583       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
37584     } CALL_CATCH_EXCEPTION();
37585   }
37586
37587 }
37588
37589
37590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
37591   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37592   Dali::PanGesture *arg2 = 0 ;
37593
37594   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37595   arg2 = (Dali::PanGesture *)jarg2;
37596   if (!arg2) {
37597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
37598     return ;
37599   }
37600   {
37601     try {
37602       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
37603     } CALL_CATCH_EXCEPTION();
37604   }
37605
37606 }
37607
37608
37609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
37610   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37611   Dali::TapGesture *arg2 = 0 ;
37612
37613   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37614   arg2 = (Dali::TapGesture *)jarg2;
37615   if (!arg2) {
37616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
37617     return ;
37618   }
37619   {
37620     try {
37621       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
37622     } CALL_CATCH_EXCEPTION();
37623   }
37624
37625 }
37626
37627
37628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
37629   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37630   Dali::TapGesture *arg2 = 0 ;
37631
37632   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37633   arg2 = (Dali::TapGesture *)jarg2;
37634   if (!arg2) {
37635     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
37636     return ;
37637   }
37638   {
37639     try {
37640       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
37641     } CALL_CATCH_EXCEPTION();
37642   }
37643
37644 }
37645
37646
37647 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
37648   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37649   Dali::LongPressGesture *arg2 = 0 ;
37650
37651   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37652   arg2 = (Dali::LongPressGesture *)jarg2;
37653   if (!arg2) {
37654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
37655     return ;
37656   }
37657   {
37658     try {
37659       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
37660     } CALL_CATCH_EXCEPTION();
37661   }
37662
37663 }
37664
37665
37666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
37667   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37668   Dali::LongPressGesture *arg2 = 0 ;
37669
37670   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37671   arg2 = (Dali::LongPressGesture *)jarg2;
37672   if (!arg2) {
37673     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
37674     return ;
37675   }
37676   {
37677     try {
37678       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
37679     } CALL_CATCH_EXCEPTION();
37680   }
37681
37682 }
37683
37684
37685 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
37686   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37687   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
37688   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
37689
37690   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37691   arg2 = (Dali::SlotObserver *)jarg2;
37692   arg3 = (Dali::CallbackBase *)jarg3;
37693   {
37694     try {
37695       (arg1)->SignalConnected(arg2,arg3);
37696     } CALL_CATCH_EXCEPTION();
37697   }
37698
37699 }
37700
37701
37702 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
37703   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37704   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
37705   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
37706
37707   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37708   arg2 = (Dali::SlotObserver *)jarg2;
37709   arg3 = (Dali::CallbackBase *)jarg3;
37710   {
37711     try {
37712       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
37713     } CALL_CATCH_EXCEPTION();
37714   }
37715
37716 }
37717
37718
37719 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
37720   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37721   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
37722   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
37723
37724   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37725   arg2 = (Dali::SlotObserver *)jarg2;
37726   arg3 = (Dali::CallbackBase *)jarg3;
37727   {
37728     try {
37729       (arg1)->SignalDisconnected(arg2,arg3);
37730     } CALL_CATCH_EXCEPTION();
37731   }
37732
37733 }
37734
37735
37736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
37737   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37738   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
37739   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
37740
37741   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37742   arg2 = (Dali::SlotObserver *)jarg2;
37743   arg3 = (Dali::CallbackBase *)jarg3;
37744   {
37745     try {
37746       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
37747     } CALL_CATCH_EXCEPTION();
37748   }
37749
37750 }
37751
37752 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) {
37753   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
37754   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
37755   if (director) {
37756     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);
37757   }
37758 }
37759
37760
37761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
37762   void * jresult ;
37763   Dali::Toolkit::Control *arg1 = 0 ;
37764   Dali::Toolkit::Internal::Control *result = 0 ;
37765
37766   arg1 = (Dali::Toolkit::Control *)jarg1;
37767   if (!arg1) {
37768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
37769     return 0;
37770   }
37771   {
37772     try {
37773       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
37774     } CALL_CATCH_EXCEPTION(0);
37775   }
37776
37777   jresult = (void *)result;
37778   return jresult;
37779 }
37780
37781
37782 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
37783   int jresult ;
37784   int result;
37785
37786   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
37787   jresult = (int)result;
37788   return jresult;
37789 }
37790
37791 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
37792   int jresult ;
37793   int result;
37794
37795   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
37796   jresult = (int)result;
37797   return jresult;
37798 }
37799
37800
37801 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
37802   int jresult ;
37803   int result;
37804
37805   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
37806   jresult = (int)result;
37807   return jresult;
37808 }
37809
37810 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_MARGIN_get() {
37811   int jresult ;
37812   int result;
37813
37814   result = (int)Dali::Toolkit::Control::Property::MARGIN;
37815   jresult = (int)result;
37816   return jresult;
37817 }
37818
37819
37820 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_PADDING_get() {
37821   int jresult ;
37822   int result;
37823
37824   result = (int)Dali::Toolkit::Control::Property::PADDING;
37825   jresult = (int)result;
37826   return jresult;
37827 }
37828
37829 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_SHADOW_get() {
37830   int jresult ;
37831   int result;
37832
37833   result = (int)Dali::Toolkit::DevelControl::Property::SHADOW;
37834   jresult = (int)result;
37835   return jresult;
37836 }
37837
37838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
37839   void * jresult ;
37840   Dali::Toolkit::Control::Property *result = 0 ;
37841
37842   {
37843     try {
37844       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
37845     } CALL_CATCH_EXCEPTION(0);
37846   }
37847
37848   jresult = (void *)result;
37849   return jresult;
37850 }
37851
37852
37853 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
37854   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
37855
37856   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
37857   {
37858     try {
37859       delete arg1;
37860     } CALL_CATCH_EXCEPTION();
37861   }
37862
37863 }
37864
37865
37866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
37867   void * jresult ;
37868   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
37869
37870   {
37871     try {
37872       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
37873     } CALL_CATCH_EXCEPTION(0);
37874   }
37875
37876   jresult = (void *)result;
37877   return jresult;
37878 }
37879
37880
37881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
37882   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
37883
37884   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
37885   {
37886     try {
37887       delete arg1;
37888     } CALL_CATCH_EXCEPTION();
37889   }
37890
37891 }
37892
37893
37894 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
37895   void * jresult ;
37896   Dali::Toolkit::Control result;
37897
37898   {
37899     try {
37900       result = Dali::Toolkit::Control::New();
37901     } CALL_CATCH_EXCEPTION(0);
37902   }
37903
37904   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
37905   return jresult;
37906 }
37907
37908
37909 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
37910   void * jresult ;
37911   Dali::Toolkit::Control *result = 0 ;
37912
37913   {
37914     try {
37915       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
37916     } CALL_CATCH_EXCEPTION(0);
37917   }
37918
37919   jresult = (void *)result;
37920   return jresult;
37921 }
37922
37923
37924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
37925   void * jresult ;
37926   Dali::Toolkit::Control *arg1 = 0 ;
37927   Dali::Toolkit::Control *result = 0 ;
37928
37929   arg1 = (Dali::Toolkit::Control *)jarg1;
37930   if (!arg1) {
37931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
37932     return 0;
37933   }
37934   {
37935     try {
37936       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
37937     } CALL_CATCH_EXCEPTION(0);
37938   }
37939
37940   jresult = (void *)result;
37941   return jresult;
37942 }
37943
37944
37945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
37946   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
37947
37948   arg1 = (Dali::Toolkit::Control *)jarg1;
37949   {
37950     try {
37951       delete arg1;
37952     } CALL_CATCH_EXCEPTION();
37953   }
37954
37955 }
37956
37957
37958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
37959   void * jresult ;
37960   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
37961   Dali::Toolkit::Control *arg2 = 0 ;
37962   Dali::Toolkit::Control *result = 0 ;
37963
37964   arg1 = (Dali::Toolkit::Control *)jarg1;
37965   arg2 = (Dali::Toolkit::Control *)jarg2;
37966   if (!arg2) {
37967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
37968     return 0;
37969   }
37970   {
37971     try {
37972       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
37973     } CALL_CATCH_EXCEPTION(0);
37974   }
37975
37976   jresult = (void *)result;
37977   return jresult;
37978 }
37979
37980
37981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
37982   void * jresult ;
37983   Dali::BaseHandle arg1 ;
37984   Dali::BaseHandle *argp1 ;
37985   Dali::Toolkit::Control result;
37986
37987   argp1 = (Dali::BaseHandle *)jarg1;
37988   if (!argp1) {
37989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37990     return 0;
37991   }
37992   arg1 = *argp1;
37993   {
37994     try {
37995       result = Dali::Toolkit::Control::DownCast(arg1);
37996     } CALL_CATCH_EXCEPTION(0);
37997   }
37998
37999   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
38000   return jresult;
38001 }
38002
38003
38004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
38005   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
38006
38007   arg1 = (Dali::Toolkit::Control *)jarg1;
38008   {
38009     try {
38010       (arg1)->SetKeyInputFocus();
38011     } CALL_CATCH_EXCEPTION();
38012   }
38013
38014 }
38015
38016
38017 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
38018   unsigned int jresult ;
38019   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
38020   bool result;
38021
38022   arg1 = (Dali::Toolkit::Control *)jarg1;
38023   {
38024     try {
38025       result = (bool)(arg1)->HasKeyInputFocus();
38026     } CALL_CATCH_EXCEPTION(0);
38027   }
38028
38029   jresult = result;
38030   return jresult;
38031 }
38032
38033
38034 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
38035   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
38036
38037   arg1 = (Dali::Toolkit::Control *)jarg1;
38038   {
38039     try {
38040       (arg1)->ClearKeyInputFocus();
38041     } CALL_CATCH_EXCEPTION();
38042   }
38043
38044 }
38045
38046
38047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
38048   void * jresult ;
38049   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
38050   Dali::PinchGestureDetector result;
38051
38052   arg1 = (Dali::Toolkit::Control *)jarg1;
38053   {
38054     try {
38055       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
38056     } CALL_CATCH_EXCEPTION(0);
38057   }
38058
38059   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
38060   return jresult;
38061 }
38062
38063
38064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
38065   void * jresult ;
38066   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
38067   Dali::PanGestureDetector result;
38068
38069   arg1 = (Dali::Toolkit::Control *)jarg1;
38070   {
38071     try {
38072       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
38073     } CALL_CATCH_EXCEPTION(0);
38074   }
38075
38076   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
38077   return jresult;
38078 }
38079
38080
38081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
38082   void * jresult ;
38083   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
38084   Dali::TapGestureDetector result;
38085
38086   arg1 = (Dali::Toolkit::Control *)jarg1;
38087   {
38088     try {
38089       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
38090     } CALL_CATCH_EXCEPTION(0);
38091   }
38092
38093   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
38094   return jresult;
38095 }
38096
38097
38098 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
38099   void * jresult ;
38100   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
38101   Dali::LongPressGestureDetector result;
38102
38103   arg1 = (Dali::Toolkit::Control *)jarg1;
38104   {
38105     try {
38106       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
38107     } CALL_CATCH_EXCEPTION(0);
38108   }
38109
38110   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
38111   return jresult;
38112 }
38113
38114
38115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
38116   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
38117   std::string *arg2 = 0 ;
38118
38119   arg1 = (Dali::Toolkit::Control *)jarg1;
38120   if (!jarg2) {
38121     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
38122     return ;
38123   }
38124   std::string arg2_str(jarg2);
38125   arg2 = &arg2_str;
38126   {
38127     try {
38128       (arg1)->SetStyleName((std::string const &)*arg2);
38129     } CALL_CATCH_EXCEPTION();
38130   }
38131
38132
38133   //argout typemap for const std::string&
38134
38135 }
38136
38137
38138 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
38139   char * jresult ;
38140   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
38141   std::string *result = 0 ;
38142
38143   arg1 = (Dali::Toolkit::Control *)jarg1;
38144   {
38145     try {
38146       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
38147     } CALL_CATCH_EXCEPTION(0);
38148   }
38149
38150   jresult = SWIG_csharp_string_callback(result->c_str());
38151   return jresult;
38152 }
38153
38154
38155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
38156   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
38157   Dali::Vector4 *arg2 = 0 ;
38158
38159   arg1 = (Dali::Toolkit::Control *)jarg1;
38160   arg2 = (Dali::Vector4 *)jarg2;
38161   if (!arg2) {
38162     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
38163     return ;
38164   }
38165   {
38166     try {
38167       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
38168     } CALL_CATCH_EXCEPTION();
38169   }
38170
38171 }
38172
38173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
38174   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
38175
38176   arg1 = (Dali::Toolkit::Control *)jarg1;
38177   {
38178     try {
38179       (arg1)->ClearBackground();
38180     } CALL_CATCH_EXCEPTION();
38181   }
38182
38183 }
38184
38185
38186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyEventSignal(void * jarg1) {
38187   void * jresult ;
38188   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
38189   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
38190
38191   arg1 = (Dali::Toolkit::Control *)jarg1;
38192   {
38193     try {
38194       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
38195     } CALL_CATCH_EXCEPTION(0);
38196   }
38197
38198   jresult = (void *)result;
38199   return jresult;
38200 }
38201
38202
38203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
38204   void * jresult ;
38205   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
38206   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
38207
38208   arg1 = (Dali::Toolkit::Control *)jarg1;
38209   {
38210     try {
38211       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
38212     } CALL_CATCH_EXCEPTION(0);
38213   }
38214
38215   jresult = (void *)result;
38216   return jresult;
38217 }
38218
38219
38220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
38221   void * jresult ;
38222   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
38223   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
38224
38225   arg1 = (Dali::Toolkit::Control *)jarg1;
38226   {
38227     try {
38228       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
38229     } CALL_CATCH_EXCEPTION(0);
38230   }
38231
38232   jresult = (void *)result;
38233   return jresult;
38234 }
38235
38236
38237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
38238   void * jresult ;
38239   Dali::Toolkit::Internal::Control *arg1 = 0 ;
38240   Dali::Toolkit::Control *result = 0 ;
38241
38242   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38243   if (!arg1) {
38244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
38245     return 0;
38246   }
38247   {
38248     try {
38249       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
38250     } CALL_CATCH_EXCEPTION(0);
38251   }
38252
38253   jresult = (void *)result;
38254   return jresult;
38255 }
38256
38257 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_GetVisualResourceStatus(void * jarg1, int jarg2)
38258 {
38259   int jresult;
38260   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
38261   arg1 = (Dali::Toolkit::Control *)jarg1;
38262
38263   if (!arg1) {
38264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
38265     return 0;
38266   }
38267
38268   Dali::Property::Index arg2 = 0 ;
38269   arg2 = (Dali::Property::Index)jarg2;
38270
38271   Toolkit::Visual::ResourceStatus result;
38272   {
38273     try {
38274       result = arg1->GetVisualResourceStatus(arg2);
38275     } CALL_CATCH_EXCEPTION(0);
38276   }
38277
38278   jresult = (int)result;
38279   return jresult;
38280 }
38281
38282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_CreateTransition(void * jarg1, void * jarg2)
38283 {
38284   void * jresult;
38285   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
38286   arg1 = (Dali::Toolkit::Control *)jarg1;
38287
38288   Dali::Toolkit::Internal::Control& controlImpl = Dali::Toolkit::Internal::GetImplementation( *arg1 );
38289
38290   Dali::Toolkit::TransitionData *arg2 = 0 ;
38291   Dali::Animation result;
38292
38293   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
38294   if (!arg2) {
38295     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
38296     return 0;
38297   }
38298   {
38299     try {
38300       result = DevelControl::CreateTransition( controlImpl, (Dali::Toolkit::TransitionData const &)*arg2);
38301     } CALL_CATCH_EXCEPTION(0);
38302   }
38303
38304   jresult = new Dali::Animation((const Dali::Animation &)result);
38305   return jresult;
38306 }
38307
38308 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_DoAction(void * jarg1, int jarg2, int jarg3, void * jarg4 )
38309 {
38310   Dali::Toolkit::Control arg1;
38311   Dali::Toolkit::Control *argp1  = (Dali::Toolkit::Control *)jarg1;
38312
38313   if (!argp1) {
38314     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
38315   }
38316   arg1 = *argp1;
38317
38318   Dali::Property::Index arg2 = 0 ;
38319   arg2 = (Dali::Property::Index)jarg2;
38320
38321   Dali::Property::Index arg3 = 0 ;
38322   arg3 = (Dali::Property::Index)jarg3;
38323
38324   Dali::Property::Value *arg4 = (Dali::Property::Value *)jarg4;
38325
38326   {
38327     try {
38328       DevelControl::DoAction(arg1, arg2, arg3, *arg4);
38329     } CALL_CATCH_EXCEPTION();
38330   }
38331 }
38332
38333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceReadySignal(void * jarg1) {
38334   void * jresult ;
38335   Dali::Toolkit::Control *arg1 = 0 ;
38336   Dali::Toolkit::Control::ResourceReadySignalType *result = 0 ;
38337
38338   arg1 = (Dali::Toolkit::Control *)jarg1;
38339   if (!arg1) {
38340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
38341     return 0;
38342   }
38343   {
38344     try {
38345       result = (Dali::Toolkit::Control::ResourceReadySignalType *) &arg1->ResourceReadySignal();
38346     } CALL_CATCH_EXCEPTION(0);
38347   }
38348
38349   jresult = (void *)result;
38350   return jresult;
38351 }
38352
38353
38354 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsResourceReady(void * jarg1) {
38355   unsigned int jresult ;
38356   Dali::Toolkit::Control *arg1 = 0 ;
38357   bool result;
38358
38359   arg1 = (Dali::Toolkit::Control *)jarg1;
38360   if (!arg1) {
38361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
38362     return 0;
38363   }
38364   {
38365     try {
38366       result = (bool)arg1->IsResourceReady();
38367     } CALL_CATCH_EXCEPTION(0);
38368   }
38369
38370   jresult = result;
38371   return jresult;
38372 }
38373
38374
38375 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
38376   void * jresult ;
38377   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
38378
38379   {
38380     try {
38381       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
38382     } CALL_CATCH_EXCEPTION(0);
38383   }
38384
38385   jresult = (void *)result;
38386   return jresult;
38387 }
38388
38389
38390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
38391   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
38392
38393   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
38394   {
38395     try {
38396       delete arg1;
38397     } CALL_CATCH_EXCEPTION();
38398   }
38399
38400 }
38401
38402
38403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
38404   void * jresult ;
38405   Dali::Toolkit::KeyInputFocusManager result;
38406
38407   {
38408     try {
38409       result = Dali::Toolkit::KeyInputFocusManager::Get();
38410     } CALL_CATCH_EXCEPTION(0);
38411   }
38412
38413   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
38414   return jresult;
38415 }
38416
38417
38418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
38419   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
38420   Dali::Toolkit::Control arg2 ;
38421   Dali::Toolkit::Control *argp2 ;
38422
38423   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
38424   argp2 = (Dali::Toolkit::Control *)jarg2;
38425   if (!argp2) {
38426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
38427     return ;
38428   }
38429   arg2 = *argp2;
38430   {
38431     try {
38432       (arg1)->SetFocus(arg2);
38433     } CALL_CATCH_EXCEPTION();
38434   }
38435
38436 }
38437
38438
38439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
38440   void * jresult ;
38441   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
38442   Dali::Toolkit::Control result;
38443
38444   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
38445   {
38446     try {
38447       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
38448     } CALL_CATCH_EXCEPTION(0);
38449   }
38450
38451   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
38452   return jresult;
38453 }
38454
38455
38456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
38457   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
38458   Dali::Toolkit::Control arg2 ;
38459   Dali::Toolkit::Control *argp2 ;
38460
38461   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
38462   argp2 = (Dali::Toolkit::Control *)jarg2;
38463   if (!argp2) {
38464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
38465     return ;
38466   }
38467   arg2 = *argp2;
38468   {
38469     try {
38470       (arg1)->RemoveFocus(arg2);
38471     } CALL_CATCH_EXCEPTION();
38472   }
38473
38474 }
38475
38476
38477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
38478   void * jresult ;
38479   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
38480   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
38481
38482   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
38483   {
38484     try {
38485       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
38486     } CALL_CATCH_EXCEPTION(0);
38487   }
38488
38489   jresult = (void *)result;
38490   return jresult;
38491 }
38492
38493
38494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
38495   void * jresult ;
38496   Dali::Toolkit::Alignment::Padding *result = 0 ;
38497
38498   {
38499     try {
38500       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
38501     } CALL_CATCH_EXCEPTION(0);
38502   }
38503
38504   jresult = (void *)result;
38505   return jresult;
38506 }
38507
38508
38509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
38510   void * jresult ;
38511   float arg1 ;
38512   float arg2 ;
38513   float arg3 ;
38514   float arg4 ;
38515   Dali::Toolkit::Alignment::Padding *result = 0 ;
38516
38517   arg1 = (float)jarg1;
38518   arg2 = (float)jarg2;
38519   arg3 = (float)jarg3;
38520   arg4 = (float)jarg4;
38521   {
38522     try {
38523       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
38524     } CALL_CATCH_EXCEPTION(0);
38525   }
38526
38527   jresult = (void *)result;
38528   return jresult;
38529 }
38530
38531
38532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
38533   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
38534   float arg2 ;
38535
38536   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
38537   arg2 = (float)jarg2;
38538   if (arg1) (arg1)->left = arg2;
38539 }
38540
38541
38542 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
38543   float jresult ;
38544   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
38545   float result;
38546
38547   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
38548   result = (float) ((arg1)->left);
38549   jresult = result;
38550   return jresult;
38551 }
38552
38553
38554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
38555   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
38556   float arg2 ;
38557
38558   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
38559   arg2 = (float)jarg2;
38560   if (arg1) (arg1)->right = arg2;
38561 }
38562
38563
38564 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
38565   float jresult ;
38566   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
38567   float result;
38568
38569   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
38570   result = (float) ((arg1)->right);
38571   jresult = result;
38572   return jresult;
38573 }
38574
38575
38576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
38577   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
38578   float arg2 ;
38579
38580   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
38581   arg2 = (float)jarg2;
38582   if (arg1) (arg1)->top = arg2;
38583 }
38584
38585
38586 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
38587   float jresult ;
38588   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
38589   float result;
38590
38591   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
38592   result = (float) ((arg1)->top);
38593   jresult = result;
38594   return jresult;
38595 }
38596
38597
38598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
38599   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
38600   float arg2 ;
38601
38602   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
38603   arg2 = (float)jarg2;
38604   if (arg1) (arg1)->bottom = arg2;
38605 }
38606
38607
38608 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
38609   float jresult ;
38610   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
38611   float result;
38612
38613   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
38614   result = (float) ((arg1)->bottom);
38615   jresult = result;
38616   return jresult;
38617 }
38618
38619
38620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
38621   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
38622
38623   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
38624   {
38625     try {
38626       delete arg1;
38627     } CALL_CATCH_EXCEPTION();
38628   }
38629
38630 }
38631
38632
38633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
38634   void * jresult ;
38635   Dali::Toolkit::Alignment *result = 0 ;
38636
38637   {
38638     try {
38639       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
38640     } CALL_CATCH_EXCEPTION(0);
38641   }
38642
38643   jresult = (void *)result;
38644   return jresult;
38645 }
38646
38647
38648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
38649   void * jresult ;
38650   Dali::Toolkit::Alignment::Type arg1 ;
38651   Dali::Toolkit::Alignment::Type arg2 ;
38652   Dali::Toolkit::Alignment result;
38653
38654   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
38655   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
38656   {
38657     try {
38658       result = Dali::Toolkit::Alignment::New(arg1,arg2);
38659     } CALL_CATCH_EXCEPTION(0);
38660   }
38661
38662   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
38663   return jresult;
38664 }
38665
38666
38667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
38668   void * jresult ;
38669   Dali::Toolkit::Alignment::Type arg1 ;
38670   Dali::Toolkit::Alignment result;
38671
38672   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
38673   {
38674     try {
38675       result = Dali::Toolkit::Alignment::New(arg1);
38676     } CALL_CATCH_EXCEPTION(0);
38677   }
38678
38679   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
38680   return jresult;
38681 }
38682
38683
38684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
38685   void * jresult ;
38686   Dali::Toolkit::Alignment result;
38687
38688   {
38689     try {
38690       result = Dali::Toolkit::Alignment::New();
38691     } CALL_CATCH_EXCEPTION(0);
38692   }
38693
38694   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
38695   return jresult;
38696 }
38697
38698
38699 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
38700   void * jresult ;
38701   Dali::Toolkit::Alignment *arg1 = 0 ;
38702   Dali::Toolkit::Alignment *result = 0 ;
38703
38704   arg1 = (Dali::Toolkit::Alignment *)jarg1;
38705   if (!arg1) {
38706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
38707     return 0;
38708   }
38709   {
38710     try {
38711       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
38712     } CALL_CATCH_EXCEPTION(0);
38713   }
38714
38715   jresult = (void *)result;
38716   return jresult;
38717 }
38718
38719
38720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
38721   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
38722
38723   arg1 = (Dali::Toolkit::Alignment *)jarg1;
38724   {
38725     try {
38726       delete arg1;
38727     } CALL_CATCH_EXCEPTION();
38728   }
38729
38730 }
38731
38732
38733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
38734   void * jresult ;
38735   Dali::BaseHandle arg1 ;
38736   Dali::BaseHandle *argp1 ;
38737   Dali::Toolkit::Alignment result;
38738
38739   argp1 = (Dali::BaseHandle *)jarg1;
38740   if (!argp1) {
38741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
38742     return 0;
38743   }
38744   arg1 = *argp1;
38745   {
38746     try {
38747       result = Dali::Toolkit::Alignment::DownCast(arg1);
38748     } CALL_CATCH_EXCEPTION(0);
38749   }
38750
38751   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
38752   return jresult;
38753 }
38754
38755
38756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
38757   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
38758   Dali::Toolkit::Alignment::Type arg2 ;
38759
38760   arg1 = (Dali::Toolkit::Alignment *)jarg1;
38761   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
38762   {
38763     try {
38764       (arg1)->SetAlignmentType(arg2);
38765     } CALL_CATCH_EXCEPTION();
38766   }
38767
38768 }
38769
38770
38771 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
38772   int jresult ;
38773   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
38774   Dali::Toolkit::Alignment::Type result;
38775
38776   arg1 = (Dali::Toolkit::Alignment *)jarg1;
38777   {
38778     try {
38779       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
38780     } CALL_CATCH_EXCEPTION(0);
38781   }
38782
38783   jresult = (int)result;
38784   return jresult;
38785 }
38786
38787
38788 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
38789   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
38790   Dali::Toolkit::Alignment::Scaling arg2 ;
38791
38792   arg1 = (Dali::Toolkit::Alignment *)jarg1;
38793   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
38794   {
38795     try {
38796       (arg1)->SetScaling(arg2);
38797     } CALL_CATCH_EXCEPTION();
38798   }
38799
38800 }
38801
38802
38803 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
38804   int jresult ;
38805   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
38806   Dali::Toolkit::Alignment::Scaling result;
38807
38808   arg1 = (Dali::Toolkit::Alignment *)jarg1;
38809   {
38810     try {
38811       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
38812     } CALL_CATCH_EXCEPTION(0);
38813   }
38814
38815   jresult = (int)result;
38816   return jresult;
38817 }
38818
38819
38820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
38821   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
38822   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
38823
38824   arg1 = (Dali::Toolkit::Alignment *)jarg1;
38825   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
38826   if (!arg2) {
38827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
38828     return ;
38829   }
38830   {
38831     try {
38832       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
38833     } CALL_CATCH_EXCEPTION();
38834   }
38835
38836 }
38837
38838
38839 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
38840   void * jresult ;
38841   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
38842   Dali::Toolkit::Alignment::Padding *result = 0 ;
38843
38844   arg1 = (Dali::Toolkit::Alignment *)jarg1;
38845   {
38846     try {
38847       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
38848     } CALL_CATCH_EXCEPTION(0);
38849   }
38850
38851   jresult = (void *)result;
38852   return jresult;
38853 }
38854
38855
38856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
38857   void * jresult ;
38858   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
38859   Dali::Toolkit::Alignment *arg2 = 0 ;
38860   Dali::Toolkit::Alignment *result = 0 ;
38861
38862   arg1 = (Dali::Toolkit::Alignment *)jarg1;
38863   arg2 = (Dali::Toolkit::Alignment *)jarg2;
38864   if (!arg2) {
38865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
38866     return 0;
38867   }
38868   {
38869     try {
38870       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
38871     } CALL_CATCH_EXCEPTION(0);
38872   }
38873
38874   jresult = (void *)result;
38875   return jresult;
38876 }
38877
38878
38879 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
38880   int jresult ;
38881   int result;
38882
38883   result = (int)Dali::Toolkit::Button::Property::DISABLED;
38884   jresult = (int)result;
38885   return jresult;
38886 }
38887
38888
38889 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
38890   int jresult ;
38891   int result;
38892
38893   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
38894   jresult = (int)result;
38895   return jresult;
38896 }
38897
38898
38899 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
38900   int jresult ;
38901   int result;
38902
38903   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
38904   jresult = (int)result;
38905   return jresult;
38906 }
38907
38908
38909 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
38910   int jresult ;
38911   int result;
38912
38913   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
38914   jresult = (int)result;
38915   return jresult;
38916 }
38917
38918
38919 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
38920   int jresult ;
38921   int result;
38922
38923   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
38924   jresult = (int)result;
38925   return jresult;
38926 }
38927
38928
38929 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
38930   int jresult ;
38931   int result;
38932
38933   result = (int)Dali::Toolkit::Button::Property::SELECTED;
38934   jresult = (int)result;
38935   return jresult;
38936 }
38937
38938 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
38939   int jresult ;
38940   int result;
38941
38942   result = (int)Dali::Toolkit::Button::Property::LABEL;
38943   jresult = (int)result;
38944   return jresult;
38945 }
38946
38947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
38948   void * jresult ;
38949   Dali::Toolkit::Button::Property *result = 0 ;
38950
38951   {
38952     try {
38953       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
38954     } CALL_CATCH_EXCEPTION(0);
38955   }
38956
38957   jresult = (void *)result;
38958   return jresult;
38959 }
38960
38961
38962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
38963   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
38964
38965   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
38966   {
38967     try {
38968       delete arg1;
38969     } CALL_CATCH_EXCEPTION();
38970   }
38971
38972 }
38973
38974
38975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
38976   void * jresult ;
38977   Dali::Toolkit::Button *result = 0 ;
38978
38979   {
38980     try {
38981       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
38982     } CALL_CATCH_EXCEPTION(0);
38983   }
38984
38985   jresult = (void *)result;
38986   return jresult;
38987 }
38988
38989
38990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
38991   void * jresult ;
38992   Dali::Toolkit::Button *arg1 = 0 ;
38993   Dali::Toolkit::Button *result = 0 ;
38994
38995   arg1 = (Dali::Toolkit::Button *)jarg1;
38996   if (!arg1) {
38997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
38998     return 0;
38999   }
39000   {
39001     try {
39002       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
39003     } CALL_CATCH_EXCEPTION(0);
39004   }
39005
39006   jresult = (void *)result;
39007   return jresult;
39008 }
39009
39010
39011 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
39012   void * jresult ;
39013   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
39014   Dali::Toolkit::Button *arg2 = 0 ;
39015   Dali::Toolkit::Button *result = 0 ;
39016
39017   arg1 = (Dali::Toolkit::Button *)jarg1;
39018   arg2 = (Dali::Toolkit::Button *)jarg2;
39019   if (!arg2) {
39020     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
39021     return 0;
39022   }
39023   {
39024     try {
39025       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
39026     } CALL_CATCH_EXCEPTION(0);
39027   }
39028
39029   jresult = (void *)result;
39030   return jresult;
39031 }
39032
39033
39034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
39035   void * jresult ;
39036   Dali::BaseHandle arg1 ;
39037   Dali::BaseHandle *argp1 ;
39038   Dali::Toolkit::Button result;
39039
39040   argp1 = (Dali::BaseHandle *)jarg1;
39041   if (!argp1) {
39042     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
39043     return 0;
39044   }
39045   arg1 = *argp1;
39046   {
39047     try {
39048       result = Dali::Toolkit::Button::DownCast(arg1);
39049     } CALL_CATCH_EXCEPTION(0);
39050   }
39051
39052   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
39053   return jresult;
39054 }
39055
39056
39057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
39058   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
39059
39060   arg1 = (Dali::Toolkit::Button *)jarg1;
39061   {
39062     try {
39063       delete arg1;
39064     } CALL_CATCH_EXCEPTION();
39065   }
39066
39067 }
39068
39069 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
39070   void * jresult ;
39071   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
39072   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
39073
39074   arg1 = (Dali::Toolkit::Button *)jarg1;
39075   {
39076     try {
39077       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
39078     } CALL_CATCH_EXCEPTION(0);
39079   }
39080
39081   jresult = (void *)result;
39082   return jresult;
39083 }
39084
39085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
39086   void * jresult ;
39087   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
39088   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
39089
39090   arg1 = (Dali::Toolkit::Button *)jarg1;
39091   {
39092     try {
39093       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
39094     } CALL_CATCH_EXCEPTION(0);
39095   }
39096
39097   jresult = (void *)result;
39098   return jresult;
39099 }
39100
39101
39102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
39103   void * jresult ;
39104   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
39105   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
39106
39107   arg1 = (Dali::Toolkit::Button *)jarg1;
39108   {
39109     try {
39110       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
39111     } CALL_CATCH_EXCEPTION(0);
39112   }
39113
39114   jresult = (void *)result;
39115   return jresult;
39116 }
39117
39118
39119 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
39120   void * jresult ;
39121   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
39122   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
39123
39124   arg1 = (Dali::Toolkit::Button *)jarg1;
39125   {
39126     try {
39127       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
39128     } CALL_CATCH_EXCEPTION(0);
39129   }
39130
39131   jresult = (void *)result;
39132   return jresult;
39133 }
39134
39135
39136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
39137   void * jresult ;
39138   Dali::Toolkit::CheckBoxButton *result = 0 ;
39139
39140   {
39141     try {
39142       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
39143     } CALL_CATCH_EXCEPTION(0);
39144   }
39145
39146   jresult = (void *)result;
39147   return jresult;
39148 }
39149
39150
39151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
39152   void * jresult ;
39153   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
39154   Dali::Toolkit::CheckBoxButton *result = 0 ;
39155
39156   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
39157   if (!arg1) {
39158     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
39159     return 0;
39160   }
39161   {
39162     try {
39163       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
39164     } CALL_CATCH_EXCEPTION(0);
39165   }
39166
39167   jresult = (void *)result;
39168   return jresult;
39169 }
39170
39171
39172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
39173   void * jresult ;
39174   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
39175   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
39176   Dali::Toolkit::CheckBoxButton *result = 0 ;
39177
39178   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
39179   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
39180   if (!arg2) {
39181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
39182     return 0;
39183   }
39184   {
39185     try {
39186       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
39187     } CALL_CATCH_EXCEPTION(0);
39188   }
39189
39190   jresult = (void *)result;
39191   return jresult;
39192 }
39193
39194
39195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
39196   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
39197
39198   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
39199   {
39200     try {
39201       delete arg1;
39202     } CALL_CATCH_EXCEPTION();
39203   }
39204
39205 }
39206
39207
39208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
39209   void * jresult ;
39210   Dali::Toolkit::CheckBoxButton result;
39211
39212   {
39213     try {
39214       result = Dali::Toolkit::CheckBoxButton::New();
39215     } CALL_CATCH_EXCEPTION(0);
39216   }
39217
39218   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
39219   return jresult;
39220 }
39221
39222
39223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
39224   void * jresult ;
39225   Dali::BaseHandle arg1 ;
39226   Dali::BaseHandle *argp1 ;
39227   Dali::Toolkit::CheckBoxButton result;
39228
39229   argp1 = (Dali::BaseHandle *)jarg1;
39230   if (!argp1) {
39231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
39232     return 0;
39233   }
39234   arg1 = *argp1;
39235   {
39236     try {
39237       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
39238     } CALL_CATCH_EXCEPTION(0);
39239   }
39240
39241   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
39242   return jresult;
39243 }
39244
39245
39246 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
39247   int jresult ;
39248   int result;
39249
39250   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
39251   jresult = (int)result;
39252   return jresult;
39253 }
39254
39255
39256 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
39257   int jresult ;
39258   int result;
39259
39260   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
39261   jresult = (int)result;
39262   return jresult;
39263 }
39264
39265
39266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
39267   void * jresult ;
39268   Dali::Toolkit::PushButton::Property *result = 0 ;
39269
39270   {
39271     try {
39272       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
39273     } CALL_CATCH_EXCEPTION(0);
39274   }
39275
39276   jresult = (void *)result;
39277   return jresult;
39278 }
39279
39280
39281 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
39282   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
39283
39284   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
39285   {
39286     try {
39287       delete arg1;
39288     } CALL_CATCH_EXCEPTION();
39289   }
39290
39291 }
39292
39293
39294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
39295   void * jresult ;
39296   Dali::Toolkit::PushButton *result = 0 ;
39297
39298   {
39299     try {
39300       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
39301     } CALL_CATCH_EXCEPTION(0);
39302   }
39303
39304   jresult = (void *)result;
39305   return jresult;
39306 }
39307
39308
39309 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
39310   void * jresult ;
39311   Dali::Toolkit::PushButton *arg1 = 0 ;
39312   Dali::Toolkit::PushButton *result = 0 ;
39313
39314   arg1 = (Dali::Toolkit::PushButton *)jarg1;
39315   if (!arg1) {
39316     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
39317     return 0;
39318   }
39319   {
39320     try {
39321       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
39322     } CALL_CATCH_EXCEPTION(0);
39323   }
39324
39325   jresult = (void *)result;
39326   return jresult;
39327 }
39328
39329
39330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
39331   void * jresult ;
39332   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
39333   Dali::Toolkit::PushButton *arg2 = 0 ;
39334   Dali::Toolkit::PushButton *result = 0 ;
39335
39336   arg1 = (Dali::Toolkit::PushButton *)jarg1;
39337   arg2 = (Dali::Toolkit::PushButton *)jarg2;
39338   if (!arg2) {
39339     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
39340     return 0;
39341   }
39342   {
39343     try {
39344       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
39345     } CALL_CATCH_EXCEPTION(0);
39346   }
39347
39348   jresult = (void *)result;
39349   return jresult;
39350 }
39351
39352
39353 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
39354   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
39355
39356   arg1 = (Dali::Toolkit::PushButton *)jarg1;
39357   {
39358     try {
39359       delete arg1;
39360     } CALL_CATCH_EXCEPTION();
39361   }
39362
39363 }
39364
39365
39366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
39367   void * jresult ;
39368   Dali::Toolkit::PushButton result;
39369
39370   {
39371     try {
39372       result = Dali::Toolkit::PushButton::New();
39373     } CALL_CATCH_EXCEPTION(0);
39374   }
39375
39376   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
39377   return jresult;
39378 }
39379
39380
39381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
39382   void * jresult ;
39383   Dali::BaseHandle arg1 ;
39384   Dali::BaseHandle *argp1 ;
39385   Dali::Toolkit::PushButton result;
39386
39387   argp1 = (Dali::BaseHandle *)jarg1;
39388   if (!argp1) {
39389     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
39390     return 0;
39391   }
39392   arg1 = *argp1;
39393   {
39394     try {
39395       result = Dali::Toolkit::PushButton::DownCast(arg1);
39396     } CALL_CATCH_EXCEPTION(0);
39397   }
39398
39399   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
39400   return jresult;
39401 }
39402
39403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
39404   void * jresult ;
39405   Dali::Toolkit::RadioButton *result = 0 ;
39406
39407   {
39408     try {
39409       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
39410     } CALL_CATCH_EXCEPTION(0);
39411   }
39412
39413   jresult = (void *)result;
39414   return jresult;
39415 }
39416
39417
39418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
39419   void * jresult ;
39420   Dali::Toolkit::RadioButton *arg1 = 0 ;
39421   Dali::Toolkit::RadioButton *result = 0 ;
39422
39423   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
39424   if (!arg1) {
39425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
39426     return 0;
39427   }
39428   {
39429     try {
39430       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
39431     } CALL_CATCH_EXCEPTION(0);
39432   }
39433
39434   jresult = (void *)result;
39435   return jresult;
39436 }
39437
39438
39439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
39440   void * jresult ;
39441   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
39442   Dali::Toolkit::RadioButton *arg2 = 0 ;
39443   Dali::Toolkit::RadioButton *result = 0 ;
39444
39445   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
39446   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
39447   if (!arg2) {
39448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
39449     return 0;
39450   }
39451   {
39452     try {
39453       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
39454     } CALL_CATCH_EXCEPTION(0);
39455   }
39456
39457   jresult = (void *)result;
39458   return jresult;
39459 }
39460
39461
39462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
39463   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
39464
39465   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
39466   {
39467     try {
39468       delete arg1;
39469     } CALL_CATCH_EXCEPTION();
39470   }
39471
39472 }
39473
39474
39475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
39476   void * jresult ;
39477   Dali::Toolkit::RadioButton result;
39478
39479   {
39480     try {
39481       result = Dali::Toolkit::RadioButton::New();
39482     } CALL_CATCH_EXCEPTION(0);
39483   }
39484
39485   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
39486   return jresult;
39487 }
39488
39489
39490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
39491   void * jresult ;
39492   std::string *arg1 = 0 ;
39493   Dali::Toolkit::RadioButton result;
39494
39495   if (!jarg1) {
39496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
39497     return 0;
39498   }
39499   std::string arg1_str(jarg1);
39500   arg1 = &arg1_str;
39501   {
39502     try {
39503       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
39504     } CALL_CATCH_EXCEPTION(0);
39505   }
39506
39507   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
39508
39509   //argout typemap for const std::string&
39510
39511   return jresult;
39512 }
39513
39514
39515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
39516   void * jresult ;
39517   Dali::BaseHandle arg1 ;
39518   Dali::BaseHandle *argp1 ;
39519   Dali::Toolkit::RadioButton result;
39520
39521   argp1 = (Dali::BaseHandle *)jarg1;
39522   if (!argp1) {
39523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
39524     return 0;
39525   }
39526   arg1 = *argp1;
39527   {
39528     try {
39529       result = Dali::Toolkit::RadioButton::DownCast(arg1);
39530     } CALL_CATCH_EXCEPTION(0);
39531   }
39532
39533   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
39534   return jresult;
39535 }
39536
39537
39538 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
39539   int jresult ;
39540   int result;
39541
39542   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
39543   jresult = (int)result;
39544   return jresult;
39545 }
39546
39547
39548 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
39549   int jresult ;
39550   int result;
39551
39552   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
39553   jresult = (int)result;
39554   return jresult;
39555 }
39556
39557
39558 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
39559   int jresult ;
39560   int result;
39561
39562   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
39563   jresult = (int)result;
39564   return jresult;
39565 }
39566
39567
39568 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
39569   int jresult ;
39570   int result;
39571
39572   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
39573   jresult = (int)result;
39574   return jresult;
39575 }
39576
39577
39578 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
39579   int jresult ;
39580   int result;
39581
39582   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
39583   jresult = (int)result;
39584   return jresult;
39585 }
39586
39587
39588 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
39589   int jresult ;
39590   int result;
39591
39592   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
39593   jresult = (int)result;
39594   return jresult;
39595 }
39596
39597
39598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
39599   void * jresult ;
39600   Dali::Toolkit::FlexContainer::Property *result = 0 ;
39601
39602   {
39603     try {
39604       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
39605     } CALL_CATCH_EXCEPTION(0);
39606   }
39607
39608   jresult = (void *)result;
39609   return jresult;
39610 }
39611
39612
39613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
39614   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
39615
39616   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
39617   {
39618     try {
39619       delete arg1;
39620     } CALL_CATCH_EXCEPTION();
39621   }
39622
39623 }
39624
39625
39626 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
39627   int jresult ;
39628   int result;
39629
39630   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
39631   jresult = (int)result;
39632   return jresult;
39633 }
39634
39635
39636 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
39637   int jresult ;
39638   int result;
39639
39640   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
39641   jresult = (int)result;
39642   return jresult;
39643 }
39644
39645
39646 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
39647   int jresult ;
39648   int result;
39649
39650   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
39651   jresult = (int)result;
39652   return jresult;
39653 }
39654
39655
39656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
39657   void * jresult ;
39658   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
39659
39660   {
39661     try {
39662       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
39663     } CALL_CATCH_EXCEPTION(0);
39664   }
39665
39666   jresult = (void *)result;
39667   return jresult;
39668 }
39669
39670
39671 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
39672   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
39673
39674   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
39675   {
39676     try {
39677       delete arg1;
39678     } CALL_CATCH_EXCEPTION();
39679   }
39680
39681 }
39682
39683
39684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
39685   void * jresult ;
39686   Dali::Toolkit::FlexContainer *result = 0 ;
39687
39688   {
39689     try {
39690       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
39691     } CALL_CATCH_EXCEPTION(0);
39692   }
39693
39694   jresult = (void *)result;
39695   return jresult;
39696 }
39697
39698
39699 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
39700   void * jresult ;
39701   Dali::Toolkit::FlexContainer *arg1 = 0 ;
39702   Dali::Toolkit::FlexContainer *result = 0 ;
39703
39704   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
39705   if (!arg1) {
39706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
39707     return 0;
39708   }
39709   {
39710     try {
39711       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
39712     } CALL_CATCH_EXCEPTION(0);
39713   }
39714
39715   jresult = (void *)result;
39716   return jresult;
39717 }
39718
39719
39720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
39721   void * jresult ;
39722   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
39723   Dali::Toolkit::FlexContainer *arg2 = 0 ;
39724   Dali::Toolkit::FlexContainer *result = 0 ;
39725
39726   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
39727   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
39728   if (!arg2) {
39729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
39730     return 0;
39731   }
39732   {
39733     try {
39734       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
39735     } CALL_CATCH_EXCEPTION(0);
39736   }
39737
39738   jresult = (void *)result;
39739   return jresult;
39740 }
39741
39742
39743 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
39744   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
39745
39746   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
39747   {
39748     try {
39749       delete arg1;
39750     } CALL_CATCH_EXCEPTION();
39751   }
39752
39753 }
39754
39755
39756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
39757   void * jresult ;
39758   Dali::Toolkit::FlexContainer result;
39759
39760   {
39761     try {
39762       result = Dali::Toolkit::FlexContainer::New();
39763     } CALL_CATCH_EXCEPTION(0);
39764   }
39765
39766   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
39767   return jresult;
39768 }
39769
39770
39771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
39772   void * jresult ;
39773   Dali::BaseHandle arg1 ;
39774   Dali::BaseHandle *argp1 ;
39775   Dali::Toolkit::FlexContainer result;
39776
39777   argp1 = (Dali::BaseHandle *)jarg1;
39778   if (!argp1) {
39779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
39780     return 0;
39781   }
39782   arg1 = *argp1;
39783   {
39784     try {
39785       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
39786     } CALL_CATCH_EXCEPTION(0);
39787   }
39788
39789   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
39790   return jresult;
39791 }
39792
39793 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
39794   int jresult ;
39795   int result;
39796
39797   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
39798   jresult = (int)result;
39799   return jresult;
39800 }
39801
39802
39803 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
39804   int jresult ;
39805   int result;
39806
39807   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
39808   jresult = (int)result;
39809   return jresult;
39810 }
39811
39812
39813 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
39814   int jresult ;
39815   int result;
39816
39817   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
39818   jresult = (int)result;
39819   return jresult;
39820 }
39821
39822
39823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
39824   void * jresult ;
39825   Dali::Toolkit::ImageView::Property *result = 0 ;
39826
39827   {
39828     try {
39829       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
39830     } CALL_CATCH_EXCEPTION(0);
39831   }
39832
39833   jresult = (void *)result;
39834   return jresult;
39835 }
39836
39837
39838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
39839   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
39840
39841   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
39842   {
39843     try {
39844       delete arg1;
39845     } CALL_CATCH_EXCEPTION();
39846   }
39847
39848 }
39849
39850
39851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
39852   void * jresult ;
39853   Dali::Toolkit::ImageView *result = 0 ;
39854
39855   {
39856     try {
39857       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
39858     } CALL_CATCH_EXCEPTION(0);
39859   }
39860
39861   jresult = (void *)result;
39862   return jresult;
39863 }
39864
39865
39866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
39867   void * jresult ;
39868   Dali::Toolkit::ImageView result;
39869
39870   {
39871     try {
39872       result = Dali::Toolkit::ImageView::New();
39873     } CALL_CATCH_EXCEPTION(0);
39874   }
39875
39876   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
39877   return jresult;
39878 }
39879
39880
39881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
39882   void * jresult ;
39883   std::string *arg1 = 0 ;
39884   Dali::Toolkit::ImageView result;
39885
39886   if (!jarg1) {
39887     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
39888     return 0;
39889   }
39890   std::string arg1_str(jarg1);
39891   arg1 = &arg1_str;
39892   {
39893     try {
39894       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
39895     } CALL_CATCH_EXCEPTION(0);
39896   }
39897
39898   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
39899
39900   //argout typemap for const std::string&
39901
39902   return jresult;
39903 }
39904
39905
39906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
39907   void * jresult ;
39908   std::string *arg1 = 0 ;
39909   Dali::ImageDimensions arg2 ;
39910   Dali::ImageDimensions *argp2 ;
39911   Dali::Toolkit::ImageView result;
39912
39913   if (!jarg1) {
39914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
39915     return 0;
39916   }
39917   std::string arg1_str(jarg1);
39918   arg1 = &arg1_str;
39919   argp2 = (Dali::ImageDimensions *)jarg2;
39920   if (!argp2) {
39921     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
39922     return 0;
39923   }
39924   arg2 = *argp2;
39925   {
39926     try {
39927       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
39928     } CALL_CATCH_EXCEPTION(0);
39929   }
39930
39931   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
39932
39933   //argout typemap for const std::string&
39934
39935   return jresult;
39936 }
39937
39938
39939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
39940   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
39941
39942   arg1 = (Dali::Toolkit::ImageView *)jarg1;
39943   {
39944     try {
39945       delete arg1;
39946     } CALL_CATCH_EXCEPTION();
39947   }
39948
39949 }
39950
39951
39952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
39953   void * jresult ;
39954   Dali::Toolkit::ImageView *arg1 = 0 ;
39955   Dali::Toolkit::ImageView *result = 0 ;
39956
39957   arg1 = (Dali::Toolkit::ImageView *)jarg1;
39958   if (!arg1) {
39959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
39960     return 0;
39961   }
39962   {
39963     try {
39964       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
39965     } CALL_CATCH_EXCEPTION(0);
39966   }
39967
39968   jresult = (void *)result;
39969   return jresult;
39970 }
39971
39972
39973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
39974   void * jresult ;
39975   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
39976   Dali::Toolkit::ImageView *arg2 = 0 ;
39977   Dali::Toolkit::ImageView *result = 0 ;
39978
39979   arg1 = (Dali::Toolkit::ImageView *)jarg1;
39980   arg2 = (Dali::Toolkit::ImageView *)jarg2;
39981   if (!arg2) {
39982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
39983     return 0;
39984   }
39985   {
39986     try {
39987       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
39988     } CALL_CATCH_EXCEPTION(0);
39989   }
39990
39991   jresult = (void *)result;
39992   return jresult;
39993 }
39994
39995
39996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
39997   void * jresult ;
39998   Dali::BaseHandle arg1 ;
39999   Dali::BaseHandle *argp1 ;
40000   Dali::Toolkit::ImageView result;
40001
40002   argp1 = (Dali::BaseHandle *)jarg1;
40003   if (!argp1) {
40004     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40005     return 0;
40006   }
40007   arg1 = *argp1;
40008   {
40009     try {
40010       result = Dali::Toolkit::ImageView::DownCast(arg1);
40011     } CALL_CATCH_EXCEPTION(0);
40012   }
40013
40014   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
40015   return jresult;
40016 }
40017
40018
40019 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
40020   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
40021   std::string *arg2 = 0 ;
40022
40023   arg1 = (Dali::Toolkit::ImageView *)jarg1;
40024   if (!jarg2) {
40025     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
40026     return ;
40027   }
40028   std::string arg2_str(jarg2);
40029   arg2 = &arg2_str;
40030   {
40031     try {
40032       (arg1)->SetImage((std::string const &)*arg2);
40033     } CALL_CATCH_EXCEPTION();
40034   }
40035
40036
40037   //argout typemap for const std::string&
40038
40039 }
40040
40041
40042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
40043   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
40044   std::string *arg2 = 0 ;
40045   Dali::ImageDimensions arg3 ;
40046   Dali::ImageDimensions *argp3 ;
40047
40048   arg1 = (Dali::Toolkit::ImageView *)jarg1;
40049   if (!jarg2) {
40050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
40051     return ;
40052   }
40053   std::string arg2_str(jarg2);
40054   arg2 = &arg2_str;
40055   argp3 = (Dali::ImageDimensions *)jarg3;
40056   if (!argp3) {
40057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
40058     return ;
40059   }
40060   arg3 = *argp3;
40061   {
40062     try {
40063       (arg1)->SetImage((std::string const &)*arg2,arg3);
40064     } CALL_CATCH_EXCEPTION();
40065   }
40066
40067
40068   //argout typemap for const std::string&
40069
40070 }
40071
40072
40073 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_GEOMETRY_URL_get() {
40074   int jresult ;
40075   int result;
40076
40077   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
40078   jresult = (int)result;
40079   return jresult;
40080 }
40081
40082
40083 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_MATERIAL_URL_get() {
40084   int jresult ;
40085   int result;
40086
40087   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
40088   jresult = (int)result;
40089   return jresult;
40090 }
40091
40092
40093 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_IMAGES_URL_get() {
40094   int jresult ;
40095   int result;
40096
40097   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
40098   jresult = (int)result;
40099   return jresult;
40100 }
40101
40102
40103 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_ILLUMINATION_TYPE_get() {
40104   int jresult ;
40105   int result;
40106
40107   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
40108   jresult = (int)result;
40109   return jresult;
40110 }
40111
40112
40113 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE0_URL_get() {
40114   int jresult ;
40115   int result;
40116
40117   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
40118   jresult = (int)result;
40119   return jresult;
40120 }
40121
40122
40123 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE1_URL_get() {
40124   int jresult ;
40125   int result;
40126
40127   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
40128   jresult = (int)result;
40129   return jresult;
40130 }
40131
40132
40133 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE2_URL_get() {
40134   int jresult ;
40135   int result;
40136
40137   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
40138   jresult = (int)result;
40139   return jresult;
40140 }
40141
40142
40143 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_LIGHT_POSITION_get() {
40144   int jresult ;
40145   int result;
40146
40147   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
40148   jresult = (int)result;
40149   return jresult;
40150 }
40151
40152
40153 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView_Property() {
40154   void * jresult ;
40155   Dali::Toolkit::Model3dView::Property *result = 0 ;
40156
40157   {
40158     try {
40159       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
40160     } CALL_CATCH_EXCEPTION(0);
40161   }
40162
40163   jresult = (void *)result;
40164   return jresult;
40165 }
40166
40167
40168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView_Property(void * jarg1) {
40169   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
40170
40171   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
40172   {
40173     try {
40174       delete arg1;
40175     } CALL_CATCH_EXCEPTION();
40176   }
40177
40178 }
40179
40180
40181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_0() {
40182   void * jresult ;
40183   Dali::Toolkit::Model3dView result;
40184
40185   {
40186     try {
40187       result = Dali::Toolkit::Model3dView::New();
40188     } CALL_CATCH_EXCEPTION(0);
40189   }
40190
40191   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
40192   return jresult;
40193 }
40194
40195
40196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
40197   void * jresult ;
40198   std::string *arg1 = 0 ;
40199   std::string *arg2 = 0 ;
40200   std::string *arg3 = 0 ;
40201   Dali::Toolkit::Model3dView result;
40202
40203   if (!jarg1) {
40204     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
40205     return 0;
40206   }
40207   std::string arg1_str(jarg1);
40208   arg1 = &arg1_str;
40209   if (!jarg2) {
40210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
40211     return 0;
40212   }
40213   std::string arg2_str(jarg2);
40214   arg2 = &arg2_str;
40215   if (!jarg3) {
40216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
40217     return 0;
40218   }
40219   std::string arg3_str(jarg3);
40220   arg3 = &arg3_str;
40221   {
40222     try {
40223       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
40224     } CALL_CATCH_EXCEPTION(0);
40225   }
40226
40227   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
40228
40229   //argout typemap for const std::string&
40230
40231
40232   //argout typemap for const std::string&
40233
40234
40235   //argout typemap for const std::string&
40236
40237   return jresult;
40238 }
40239
40240
40241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_0() {
40242   void * jresult ;
40243   Dali::Toolkit::Model3dView *result = 0 ;
40244
40245   {
40246     try {
40247       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
40248     } CALL_CATCH_EXCEPTION(0);
40249   }
40250
40251   jresult = (void *)result;
40252   return jresult;
40253 }
40254
40255
40256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView(void * jarg1) {
40257   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
40258
40259   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
40260   {
40261     try {
40262       delete arg1;
40263     } CALL_CATCH_EXCEPTION();
40264   }
40265
40266 }
40267
40268
40269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_1(void * jarg1) {
40270   void * jresult ;
40271   Dali::Toolkit::Model3dView *arg1 = 0 ;
40272   Dali::Toolkit::Model3dView *result = 0 ;
40273
40274   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
40275   if (!arg1) {
40276     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
40277     return 0;
40278   }
40279   {
40280     try {
40281       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
40282     } CALL_CATCH_EXCEPTION(0);
40283   }
40284
40285   jresult = (void *)result;
40286   return jresult;
40287 }
40288
40289
40290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_Assign(void * jarg1, void * jarg2) {
40291   void * jresult ;
40292   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
40293   Dali::Toolkit::Model3dView *arg2 = 0 ;
40294   Dali::Toolkit::Model3dView *result = 0 ;
40295
40296   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
40297   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
40298   if (!arg2) {
40299     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
40300     return 0;
40301   }
40302   {
40303     try {
40304       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
40305     } CALL_CATCH_EXCEPTION(0);
40306   }
40307
40308   jresult = (void *)result;
40309   return jresult;
40310 }
40311
40312
40313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_DownCast(void * jarg1) {
40314   void * jresult ;
40315   Dali::BaseHandle arg1 ;
40316   Dali::BaseHandle *argp1 ;
40317   Dali::Toolkit::Model3dView result;
40318
40319   argp1 = (Dali::BaseHandle *)jarg1;
40320   if (!argp1) {
40321     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40322     return 0;
40323   }
40324   arg1 = *argp1;
40325   {
40326     try {
40327       result = Dali::Toolkit::Model3dView::DownCast(arg1);
40328     } CALL_CATCH_EXCEPTION(0);
40329   }
40330
40331   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
40332   return jresult;
40333 }
40334
40335
40336 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
40337   int jresult ;
40338   int result;
40339
40340   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
40341   jresult = (int)result;
40342   return jresult;
40343 }
40344
40345
40346 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
40347   int jresult ;
40348   int result;
40349
40350   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
40351   jresult = (int)result;
40352   return jresult;
40353 }
40354
40355
40356 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
40357   int jresult ;
40358   int result;
40359
40360   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
40361   jresult = (int)result;
40362   return jresult;
40363 }
40364
40365
40366 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
40367   int jresult ;
40368   int result;
40369
40370   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
40371   jresult = (int)result;
40372   return jresult;
40373 }
40374
40375
40376 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
40377   int jresult ;
40378   int result;
40379
40380   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
40381   jresult = (int)result;
40382   return jresult;
40383 }
40384
40385
40386 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
40387   int jresult ;
40388   int result;
40389
40390   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
40391   jresult = (int)result;
40392   return jresult;
40393 }
40394
40395
40396 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
40397   int jresult ;
40398   int result;
40399
40400   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
40401   jresult = (int)result;
40402   return jresult;
40403 }
40404
40405
40406 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
40407   int jresult ;
40408   int result;
40409
40410   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
40411   jresult = (int)result;
40412   return jresult;
40413 }
40414
40415
40416 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
40417   int jresult ;
40418   int result;
40419
40420   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
40421   jresult = (int)result;
40422   return jresult;
40423 }
40424
40425
40426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
40427   void * jresult ;
40428   Dali::Toolkit::ScrollBar::Property *result = 0 ;
40429
40430   {
40431     try {
40432       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
40433     } CALL_CATCH_EXCEPTION(0);
40434   }
40435
40436   jresult = (void *)result;
40437   return jresult;
40438 }
40439
40440
40441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
40442   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
40443
40444   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
40445   {
40446     try {
40447       delete arg1;
40448     } CALL_CATCH_EXCEPTION();
40449   }
40450
40451 }
40452
40453
40454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
40455   void * jresult ;
40456   Dali::Toolkit::ScrollBar *result = 0 ;
40457
40458   {
40459     try {
40460       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
40461     } CALL_CATCH_EXCEPTION(0);
40462   }
40463
40464   jresult = (void *)result;
40465   return jresult;
40466 }
40467
40468
40469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
40470   void * jresult ;
40471   Dali::Toolkit::ScrollBar *arg1 = 0 ;
40472   Dali::Toolkit::ScrollBar *result = 0 ;
40473
40474   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40475   if (!arg1) {
40476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
40477     return 0;
40478   }
40479   {
40480     try {
40481       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
40482     } CALL_CATCH_EXCEPTION(0);
40483   }
40484
40485   jresult = (void *)result;
40486   return jresult;
40487 }
40488
40489
40490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
40491   void * jresult ;
40492   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40493   Dali::Toolkit::ScrollBar *arg2 = 0 ;
40494   Dali::Toolkit::ScrollBar *result = 0 ;
40495
40496   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40497   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
40498   if (!arg2) {
40499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
40500     return 0;
40501   }
40502   {
40503     try {
40504       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
40505     } CALL_CATCH_EXCEPTION(0);
40506   }
40507
40508   jresult = (void *)result;
40509   return jresult;
40510 }
40511
40512
40513 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
40514   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40515
40516   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40517   {
40518     try {
40519       delete arg1;
40520     } CALL_CATCH_EXCEPTION();
40521   }
40522
40523 }
40524
40525
40526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
40527   void * jresult ;
40528   Dali::Toolkit::ScrollBar::Direction arg1 ;
40529   Dali::Toolkit::ScrollBar result;
40530
40531   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
40532   {
40533     try {
40534       result = Dali::Toolkit::ScrollBar::New(arg1);
40535     } CALL_CATCH_EXCEPTION(0);
40536   }
40537
40538   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
40539   return jresult;
40540 }
40541
40542
40543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
40544   void * jresult ;
40545   Dali::Toolkit::ScrollBar result;
40546
40547   {
40548     try {
40549       result = Dali::Toolkit::ScrollBar::New();
40550     } CALL_CATCH_EXCEPTION(0);
40551   }
40552
40553   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
40554   return jresult;
40555 }
40556
40557
40558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
40559   void * jresult ;
40560   Dali::BaseHandle arg1 ;
40561   Dali::BaseHandle *argp1 ;
40562   Dali::Toolkit::ScrollBar result;
40563
40564   argp1 = (Dali::BaseHandle *)jarg1;
40565   if (!argp1) {
40566     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40567     return 0;
40568   }
40569   arg1 = *argp1;
40570   {
40571     try {
40572       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
40573     } CALL_CATCH_EXCEPTION(0);
40574   }
40575
40576   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
40577   return jresult;
40578 }
40579
40580
40581 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
40582   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40583   Dali::Handle arg2 ;
40584   Dali::Property::Index arg3 ;
40585   Dali::Property::Index arg4 ;
40586   Dali::Property::Index arg5 ;
40587   Dali::Property::Index arg6 ;
40588   Dali::Handle *argp2 ;
40589
40590   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40591   argp2 = (Dali::Handle *)jarg2;
40592   if (!argp2) {
40593     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
40594     return ;
40595   }
40596   arg2 = *argp2;
40597   arg3 = (Dali::Property::Index)jarg3;
40598   arg4 = (Dali::Property::Index)jarg4;
40599   arg5 = (Dali::Property::Index)jarg5;
40600   arg6 = (Dali::Property::Index)jarg6;
40601   {
40602     try {
40603       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
40604     } CALL_CATCH_EXCEPTION();
40605   }
40606
40607 }
40608
40609
40610 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
40611   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40612   Dali::Actor arg2 ;
40613   Dali::Actor *argp2 ;
40614
40615   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40616   argp2 = (Dali::Actor *)jarg2;
40617   if (!argp2) {
40618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40619     return ;
40620   }
40621   arg2 = *argp2;
40622   {
40623     try {
40624       (arg1)->SetScrollIndicator(arg2);
40625     } CALL_CATCH_EXCEPTION();
40626   }
40627
40628 }
40629
40630
40631 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
40632   void * jresult ;
40633   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40634   Dali::Actor result;
40635
40636   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40637   {
40638     try {
40639       result = (arg1)->GetScrollIndicator();
40640     } CALL_CATCH_EXCEPTION(0);
40641   }
40642
40643   jresult = new Dali::Actor((const Dali::Actor &)result);
40644   return jresult;
40645 }
40646
40647
40648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
40649   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40650   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
40651
40652   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40653   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
40654   if (!arg2) {
40655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
40656     return ;
40657   }
40658   {
40659     try {
40660       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
40661     } CALL_CATCH_EXCEPTION();
40662   }
40663
40664 }
40665
40666
40667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
40668   void * jresult ;
40669   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40670
40671   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40672   {
40673     try {
40674       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()));
40675     } CALL_CATCH_EXCEPTION(0);
40676   }
40677   return jresult;
40678 }
40679
40680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
40681   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40682   Dali::Toolkit::ScrollBar::Direction arg2 ;
40683
40684   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40685   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
40686   {
40687     try {
40688       (arg1)->SetScrollDirection(arg2);
40689     } CALL_CATCH_EXCEPTION();
40690   }
40691
40692 }
40693
40694
40695 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
40696   int jresult ;
40697   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40698   Dali::Toolkit::ScrollBar::Direction result;
40699
40700   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40701   {
40702     try {
40703       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
40704     } CALL_CATCH_EXCEPTION(0);
40705   }
40706
40707   jresult = (int)result;
40708   return jresult;
40709 }
40710
40711
40712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
40713   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40714   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
40715
40716   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40717   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
40718   {
40719     try {
40720       (arg1)->SetIndicatorHeightPolicy(arg2);
40721     } CALL_CATCH_EXCEPTION();
40722   }
40723
40724 }
40725
40726
40727 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
40728   int jresult ;
40729   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40730   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
40731
40732   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40733   {
40734     try {
40735       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
40736     } CALL_CATCH_EXCEPTION(0);
40737   }
40738
40739   jresult = (int)result;
40740   return jresult;
40741 }
40742
40743
40744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
40745   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40746   float arg2 ;
40747
40748   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40749   arg2 = (float)jarg2;
40750   {
40751     try {
40752       (arg1)->SetIndicatorFixedHeight(arg2);
40753     } CALL_CATCH_EXCEPTION();
40754   }
40755
40756 }
40757
40758
40759 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
40760   float jresult ;
40761   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40762   float result;
40763
40764   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40765   {
40766     try {
40767       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
40768     } CALL_CATCH_EXCEPTION(0);
40769   }
40770
40771   jresult = result;
40772   return jresult;
40773 }
40774
40775
40776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
40777   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40778   float arg2 ;
40779
40780   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40781   arg2 = (float)jarg2;
40782   {
40783     try {
40784       (arg1)->SetIndicatorShowDuration(arg2);
40785     } CALL_CATCH_EXCEPTION();
40786   }
40787
40788 }
40789
40790
40791 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
40792   float jresult ;
40793   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40794   float result;
40795
40796   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40797   {
40798     try {
40799       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
40800     } CALL_CATCH_EXCEPTION(0);
40801   }
40802
40803   jresult = result;
40804   return jresult;
40805 }
40806
40807
40808 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
40809   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40810   float arg2 ;
40811
40812   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40813   arg2 = (float)jarg2;
40814   {
40815     try {
40816       (arg1)->SetIndicatorHideDuration(arg2);
40817     } CALL_CATCH_EXCEPTION();
40818   }
40819
40820 }
40821
40822
40823 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
40824   float jresult ;
40825   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40826   float result;
40827
40828   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40829   {
40830     try {
40831       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
40832     } CALL_CATCH_EXCEPTION(0);
40833   }
40834
40835   jresult = result;
40836   return jresult;
40837 }
40838
40839
40840 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
40841   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40842
40843   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40844   {
40845     try {
40846       (arg1)->ShowIndicator();
40847     } CALL_CATCH_EXCEPTION();
40848   }
40849
40850 }
40851
40852
40853 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
40854   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40855
40856   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40857   {
40858     try {
40859       (arg1)->HideIndicator();
40860     } CALL_CATCH_EXCEPTION();
40861   }
40862
40863 }
40864
40865
40866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
40867   void * jresult ;
40868   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40869   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
40870
40871   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40872   {
40873     try {
40874       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
40875     } CALL_CATCH_EXCEPTION(0);
40876   }
40877
40878   jresult = (void *)result;
40879   return jresult;
40880 }
40881
40882
40883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
40884   void * jresult ;
40885   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40886   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
40887
40888   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40889   {
40890     try {
40891       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
40892     } CALL_CATCH_EXCEPTION(0);
40893   }
40894
40895   jresult = (void *)result;
40896   return jresult;
40897 }
40898
40899
40900 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
40901   int jresult ;
40902   int result;
40903
40904   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
40905   jresult = (int)result;
40906   return jresult;
40907 }
40908
40909
40910 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
40911   int jresult ;
40912   int result;
40913
40914   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
40915   jresult = (int)result;
40916   return jresult;
40917 }
40918
40919
40920 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
40921   int jresult ;
40922   int result;
40923
40924   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
40925   jresult = (int)result;
40926   return jresult;
40927 }
40928
40929
40930 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
40931   int jresult ;
40932   int result;
40933
40934   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
40935   jresult = (int)result;
40936   return jresult;
40937 }
40938
40939
40940 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
40941   int jresult ;
40942   int result;
40943
40944   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
40945   jresult = (int)result;
40946   return jresult;
40947 }
40948
40949
40950 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
40951   int jresult ;
40952   int result;
40953
40954   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
40955   jresult = (int)result;
40956   return jresult;
40957 }
40958
40959
40960 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
40961   int jresult ;
40962   int result;
40963
40964   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
40965   jresult = (int)result;
40966   return jresult;
40967 }
40968
40969
40970 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
40971   int jresult ;
40972   int result;
40973
40974   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
40975   jresult = (int)result;
40976   return jresult;
40977 }
40978
40979
40980 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
40981   int jresult ;
40982   int result;
40983
40984   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
40985   jresult = (int)result;
40986   return jresult;
40987 }
40988
40989
40990 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
40991   int jresult ;
40992   int result;
40993
40994   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
40995   jresult = (int)result;
40996   return jresult;
40997 }
40998
40999
41000 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
41001   int jresult ;
41002   int result;
41003
41004   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
41005   jresult = (int)result;
41006   return jresult;
41007 }
41008
41009
41010 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
41011   int jresult ;
41012   int result;
41013
41014   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
41015   jresult = (int)result;
41016   return jresult;
41017 }
41018
41019
41020 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
41021   int jresult ;
41022   int result;
41023
41024   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
41025   jresult = (int)result;
41026   return jresult;
41027 }
41028
41029
41030 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
41031   int jresult ;
41032   int result;
41033
41034   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
41035   jresult = (int)result;
41036   return jresult;
41037 }
41038
41039
41040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
41041   void * jresult ;
41042   Dali::Toolkit::Scrollable::Property *result = 0 ;
41043
41044   {
41045     try {
41046       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
41047     } CALL_CATCH_EXCEPTION(0);
41048   }
41049
41050   jresult = (void *)result;
41051   return jresult;
41052 }
41053
41054
41055 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
41056   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
41057
41058   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
41059   {
41060     try {
41061       delete arg1;
41062     } CALL_CATCH_EXCEPTION();
41063   }
41064
41065 }
41066
41067
41068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
41069   void * jresult ;
41070   Dali::Toolkit::Scrollable *result = 0 ;
41071
41072   {
41073     try {
41074       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
41075     } CALL_CATCH_EXCEPTION(0);
41076   }
41077
41078   jresult = (void *)result;
41079   return jresult;
41080 }
41081
41082
41083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
41084   void * jresult ;
41085   Dali::Toolkit::Scrollable *arg1 = 0 ;
41086   Dali::Toolkit::Scrollable *result = 0 ;
41087
41088   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
41089   if (!arg1) {
41090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
41091     return 0;
41092   }
41093   {
41094     try {
41095       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
41096     } CALL_CATCH_EXCEPTION(0);
41097   }
41098
41099   jresult = (void *)result;
41100   return jresult;
41101 }
41102
41103
41104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
41105   void * jresult ;
41106   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
41107   Dali::Toolkit::Scrollable *arg2 = 0 ;
41108   Dali::Toolkit::Scrollable *result = 0 ;
41109
41110   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
41111   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
41112   if (!arg2) {
41113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
41114     return 0;
41115   }
41116   {
41117     try {
41118       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
41119     } CALL_CATCH_EXCEPTION(0);
41120   }
41121
41122   jresult = (void *)result;
41123   return jresult;
41124 }
41125
41126
41127 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
41128   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
41129
41130   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
41131   {
41132     try {
41133       delete arg1;
41134     } CALL_CATCH_EXCEPTION();
41135   }
41136
41137 }
41138
41139
41140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
41141   void * jresult ;
41142   Dali::BaseHandle arg1 ;
41143   Dali::BaseHandle *argp1 ;
41144   Dali::Toolkit::Scrollable result;
41145
41146   argp1 = (Dali::BaseHandle *)jarg1;
41147   if (!argp1) {
41148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41149     return 0;
41150   }
41151   arg1 = *argp1;
41152   {
41153     try {
41154       result = Dali::Toolkit::Scrollable::DownCast(arg1);
41155     } CALL_CATCH_EXCEPTION(0);
41156   }
41157
41158   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
41159   return jresult;
41160 }
41161
41162
41163 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
41164   unsigned int jresult ;
41165   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
41166   bool result;
41167
41168   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
41169   {
41170     try {
41171       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
41172     } CALL_CATCH_EXCEPTION(0);
41173   }
41174
41175   jresult = result;
41176   return jresult;
41177 }
41178
41179
41180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
41181   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
41182   bool arg2 ;
41183
41184   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
41185   arg2 = jarg2 ? true : false;
41186   {
41187     try {
41188       (arg1)->SetOvershootEnabled(arg2);
41189     } CALL_CATCH_EXCEPTION();
41190   }
41191
41192 }
41193
41194
41195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
41196   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
41197   Dali::Vector4 *arg2 = 0 ;
41198
41199   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
41200   arg2 = (Dali::Vector4 *)jarg2;
41201   if (!arg2) {
41202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
41203     return ;
41204   }
41205   {
41206     try {
41207       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
41208     } CALL_CATCH_EXCEPTION();
41209   }
41210
41211 }
41212
41213
41214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
41215   void * jresult ;
41216   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
41217   Dali::Vector4 result;
41218
41219   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
41220   {
41221     try {
41222       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
41223     } CALL_CATCH_EXCEPTION(0);
41224   }
41225
41226   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
41227   return jresult;
41228 }
41229
41230
41231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
41232   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
41233   float arg2 ;
41234
41235   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
41236   arg2 = (float)jarg2;
41237   {
41238     try {
41239       (arg1)->SetOvershootAnimationSpeed(arg2);
41240     } CALL_CATCH_EXCEPTION();
41241   }
41242
41243 }
41244
41245
41246 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
41247   float jresult ;
41248   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
41249   float result;
41250
41251   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
41252   {
41253     try {
41254       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
41255     } CALL_CATCH_EXCEPTION(0);
41256   }
41257
41258   jresult = result;
41259   return jresult;
41260 }
41261
41262
41263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
41264   void * jresult ;
41265   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
41266   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
41267
41268   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
41269   {
41270     try {
41271       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
41272     } CALL_CATCH_EXCEPTION(0);
41273   }
41274
41275   jresult = (void *)result;
41276   return jresult;
41277 }
41278
41279
41280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
41281   void * jresult ;
41282   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
41283   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
41284
41285   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
41286   {
41287     try {
41288       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
41289     } CALL_CATCH_EXCEPTION(0);
41290   }
41291
41292   jresult = (void *)result;
41293   return jresult;
41294 }
41295
41296
41297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
41298   void * jresult ;
41299   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
41300   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
41301
41302   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
41303   {
41304     try {
41305       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
41306     } CALL_CATCH_EXCEPTION(0);
41307   }
41308
41309   jresult = (void *)result;
41310   return jresult;
41311 }
41312
41313
41314 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
41315   unsigned int jresult ;
41316   Dali::Toolkit::ControlOrientation::Type arg1 ;
41317   bool result;
41318
41319   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
41320   {
41321     try {
41322       result = (bool)Dali::Toolkit::IsVertical(arg1);
41323     } CALL_CATCH_EXCEPTION(0);
41324   }
41325
41326   jresult = result;
41327   return jresult;
41328 }
41329
41330
41331 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
41332   unsigned int jresult ;
41333   Dali::Toolkit::ControlOrientation::Type arg1 ;
41334   bool result;
41335
41336   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
41337   {
41338     try {
41339       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
41340     } CALL_CATCH_EXCEPTION(0);
41341   }
41342
41343   jresult = result;
41344   return jresult;
41345 }
41346
41347
41348 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
41349   void * jresult ;
41350   unsigned int arg1 ;
41351   unsigned int arg2 ;
41352   Dali::Toolkit::ItemRange *result = 0 ;
41353
41354   arg1 = (unsigned int)jarg1;
41355   arg2 = (unsigned int)jarg2;
41356   {
41357     try {
41358       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
41359     } CALL_CATCH_EXCEPTION(0);
41360   }
41361
41362   jresult = (void *)result;
41363   return jresult;
41364 }
41365
41366
41367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
41368   void * jresult ;
41369   Dali::Toolkit::ItemRange *arg1 = 0 ;
41370   Dali::Toolkit::ItemRange *result = 0 ;
41371
41372   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
41373   if (!arg1) {
41374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
41375     return 0;
41376   }
41377   {
41378     try {
41379       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
41380     } CALL_CATCH_EXCEPTION(0);
41381   }
41382
41383   jresult = (void *)result;
41384   return jresult;
41385 }
41386
41387
41388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
41389   void * jresult ;
41390   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
41391   Dali::Toolkit::ItemRange *arg2 = 0 ;
41392   Dali::Toolkit::ItemRange *result = 0 ;
41393
41394   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
41395   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
41396   if (!arg2) {
41397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
41398     return 0;
41399   }
41400   {
41401     try {
41402       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
41403     } CALL_CATCH_EXCEPTION(0);
41404   }
41405
41406   jresult = (void *)result;
41407   return jresult;
41408 }
41409
41410
41411 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
41412   unsigned int jresult ;
41413   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
41414   unsigned int arg2 ;
41415   bool result;
41416
41417   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
41418   arg2 = (unsigned int)jarg2;
41419   {
41420     try {
41421       result = (bool)(arg1)->Within(arg2);
41422     } CALL_CATCH_EXCEPTION(0);
41423   }
41424
41425   jresult = result;
41426   return jresult;
41427 }
41428
41429
41430 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
41431   void * jresult ;
41432   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
41433   Dali::Toolkit::ItemRange *arg2 = 0 ;
41434   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
41435
41436   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
41437   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
41438   if (!arg2) {
41439     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
41440     return 0;
41441   }
41442   {
41443     try {
41444       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
41445     } CALL_CATCH_EXCEPTION(0);
41446   }
41447
41448   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
41449   return jresult;
41450 }
41451
41452
41453 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
41454   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
41455   unsigned int arg2 ;
41456
41457   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
41458   arg2 = (unsigned int)jarg2;
41459   if (arg1) (arg1)->begin = arg2;
41460 }
41461
41462
41463 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
41464   unsigned int jresult ;
41465   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
41466   unsigned int result;
41467
41468   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
41469   result = (unsigned int) ((arg1)->begin);
41470   jresult = result;
41471   return jresult;
41472 }
41473
41474
41475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
41476   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
41477   unsigned int arg2 ;
41478
41479   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
41480   arg2 = (unsigned int)jarg2;
41481   if (arg1) (arg1)->end = arg2;
41482 }
41483
41484
41485 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
41486   unsigned int jresult ;
41487   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
41488   unsigned int result;
41489
41490   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
41491   result = (unsigned int) ((arg1)->end);
41492   jresult = result;
41493   return jresult;
41494 }
41495
41496
41497 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
41498   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
41499
41500   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
41501   {
41502     try {
41503       delete arg1;
41504     } CALL_CATCH_EXCEPTION();
41505   }
41506
41507 }
41508
41509
41510 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
41511   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41512
41513   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41514   {
41515     try {
41516       delete arg1;
41517     } CALL_CATCH_EXCEPTION();
41518   }
41519
41520 }
41521
41522
41523 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
41524   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41525   Dali::Toolkit::ControlOrientation::Type arg2 ;
41526
41527   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41528   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
41529   {
41530     try {
41531       (arg1)->SetOrientation(arg2);
41532     } CALL_CATCH_EXCEPTION();
41533   }
41534
41535 }
41536
41537
41538 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
41539   int jresult ;
41540   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41541   Dali::Toolkit::ControlOrientation::Type result;
41542
41543   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41544   {
41545     try {
41546       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
41547     } CALL_CATCH_EXCEPTION(0);
41548   }
41549
41550   jresult = (int)result;
41551   return jresult;
41552 }
41553
41554
41555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
41556   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41557   Dali::Property::Map *arg2 = 0 ;
41558
41559   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41560   arg2 = (Dali::Property::Map *)jarg2;
41561   if (!arg2) {
41562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
41563     return ;
41564   }
41565   {
41566     try {
41567       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
41568     } CALL_CATCH_EXCEPTION();
41569   }
41570
41571 }
41572
41573
41574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
41575   void * jresult ;
41576   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41577   Dali::Property::Map result;
41578
41579   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41580   {
41581     try {
41582       result = (arg1)->GetLayoutProperties();
41583     } CALL_CATCH_EXCEPTION(0);
41584   }
41585
41586   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
41587   return jresult;
41588 }
41589
41590
41591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
41592   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41593   unsigned int arg2 ;
41594   Dali::Vector3 *arg3 = 0 ;
41595   Dali::Vector3 *arg4 = 0 ;
41596
41597   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41598   arg2 = (unsigned int)jarg2;
41599   arg3 = (Dali::Vector3 *)jarg3;
41600   if (!arg3) {
41601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
41602     return ;
41603   }
41604   arg4 = (Dali::Vector3 *)jarg4;
41605   if (!arg4) {
41606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
41607     return ;
41608   }
41609   {
41610     try {
41611       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
41612     } CALL_CATCH_EXCEPTION();
41613   }
41614
41615 }
41616
41617
41618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
41619   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41620   Dali::Vector3 *arg2 = 0 ;
41621
41622   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41623   arg2 = (Dali::Vector3 *)jarg2;
41624   if (!arg2) {
41625     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
41626     return ;
41627   }
41628   {
41629     try {
41630       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
41631     } CALL_CATCH_EXCEPTION();
41632   }
41633
41634 }
41635
41636
41637 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
41638   float jresult ;
41639   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41640   unsigned int arg2 ;
41641   Dali::Vector3 arg3 ;
41642   Dali::Vector3 *argp3 ;
41643   float result;
41644
41645   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41646   arg2 = (unsigned int)jarg2;
41647   argp3 = (Dali::Vector3 *)jarg3;
41648   if (!argp3) {
41649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
41650     return 0;
41651   }
41652   arg3 = *argp3;
41653   {
41654     try {
41655       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
41656     } CALL_CATCH_EXCEPTION(0);
41657   }
41658
41659   jresult = result;
41660   return jresult;
41661 }
41662
41663
41664 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
41665   float jresult ;
41666   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41667   float arg2 ;
41668   float result;
41669
41670   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41671   arg2 = (float)jarg2;
41672   {
41673     try {
41674       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
41675     } CALL_CATCH_EXCEPTION(0);
41676   }
41677
41678   jresult = result;
41679   return jresult;
41680 }
41681
41682
41683 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
41684   float jresult ;
41685   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41686   unsigned int arg2 ;
41687   float result;
41688
41689   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41690   arg2 = (unsigned int)jarg2;
41691   {
41692     try {
41693       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
41694     } CALL_CATCH_EXCEPTION(0);
41695   }
41696
41697   jresult = result;
41698   return jresult;
41699 }
41700
41701
41702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
41703   void * jresult ;
41704   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41705   float arg2 ;
41706   Dali::Vector3 arg3 ;
41707   Dali::Vector3 *argp3 ;
41708   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
41709
41710   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41711   arg2 = (float)jarg2;
41712   argp3 = (Dali::Vector3 *)jarg3;
41713   if (!argp3) {
41714     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
41715     return 0;
41716   }
41717   arg3 = *argp3;
41718   {
41719     try {
41720       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
41721     } CALL_CATCH_EXCEPTION(0);
41722   }
41723
41724   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
41725   return jresult;
41726 }
41727
41728
41729 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
41730   float jresult ;
41731   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41732   int arg2 ;
41733   float arg3 ;
41734   Dali::Vector3 *arg4 = 0 ;
41735   float result;
41736
41737   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41738   arg2 = (int)jarg2;
41739   arg3 = (float)jarg3;
41740   arg4 = (Dali::Vector3 *)jarg4;
41741   if (!arg4) {
41742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
41743     return 0;
41744   }
41745   {
41746     try {
41747       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
41748     } CALL_CATCH_EXCEPTION(0);
41749   }
41750
41751   jresult = result;
41752   return jresult;
41753 }
41754
41755
41756 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
41757   unsigned int jresult ;
41758   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41759   Dali::Vector3 arg2 ;
41760   Dali::Vector3 *argp2 ;
41761   unsigned int result;
41762
41763   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41764   argp2 = (Dali::Vector3 *)jarg2;
41765   if (!argp2) {
41766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
41767     return 0;
41768   }
41769   arg2 = *argp2;
41770   {
41771     try {
41772       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
41773     } CALL_CATCH_EXCEPTION(0);
41774   }
41775
41776   jresult = result;
41777   return jresult;
41778 }
41779
41780
41781 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
41782   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41783   unsigned int arg2 ;
41784   Dali::Vector3 *arg3 = 0 ;
41785   Dali::Vector3 *arg4 = 0 ;
41786
41787   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41788   arg2 = (unsigned int)jarg2;
41789   arg3 = (Dali::Vector3 *)jarg3;
41790   if (!arg3) {
41791     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
41792     return ;
41793   }
41794   arg4 = (Dali::Vector3 *)jarg4;
41795   if (!arg4) {
41796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
41797     return ;
41798   }
41799   {
41800     try {
41801       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
41802     } CALL_CATCH_EXCEPTION();
41803   }
41804
41805 }
41806
41807
41808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
41809   void * jresult ;
41810   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41811   Dali::Degree result;
41812
41813   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41814   {
41815     try {
41816       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
41817     } CALL_CATCH_EXCEPTION(0);
41818   }
41819
41820   jresult = new Dali::Degree((const Dali::Degree &)result);
41821   return jresult;
41822 }
41823
41824
41825 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
41826   float jresult ;
41827   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41828   float result;
41829
41830   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41831   {
41832     try {
41833       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
41834     } CALL_CATCH_EXCEPTION(0);
41835   }
41836
41837   jresult = result;
41838   return jresult;
41839 }
41840
41841
41842 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
41843   float jresult ;
41844   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41845   float result;
41846
41847   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41848   {
41849     try {
41850       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
41851     } CALL_CATCH_EXCEPTION(0);
41852   }
41853
41854   jresult = result;
41855   return jresult;
41856 }
41857
41858
41859 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
41860   float jresult ;
41861   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41862   float result;
41863
41864   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41865   {
41866     try {
41867       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
41868     } CALL_CATCH_EXCEPTION(0);
41869   }
41870
41871   jresult = result;
41872   return jresult;
41873 }
41874
41875
41876 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
41877   int jresult ;
41878   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41879   int arg2 ;
41880   int arg3 ;
41881   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
41882   bool arg5 ;
41883   int result;
41884
41885   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41886   arg2 = (int)jarg2;
41887   arg3 = (int)jarg3;
41888   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
41889   arg5 = jarg5 ? true : false;
41890   {
41891     try {
41892       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
41893     } CALL_CATCH_EXCEPTION(0);
41894   }
41895
41896   jresult = result;
41897   return jresult;
41898 }
41899
41900
41901 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
41902   float jresult ;
41903   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41904   float result;
41905
41906   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41907   {
41908     try {
41909       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
41910     } CALL_CATCH_EXCEPTION(0);
41911   }
41912
41913   jresult = result;
41914   return jresult;
41915 }
41916
41917
41918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
41919   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41920   Dali::Actor *arg2 = 0 ;
41921   int arg3 ;
41922   Dali::Vector3 *arg4 = 0 ;
41923   Dali::Actor *arg5 = 0 ;
41924
41925   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41926   arg2 = (Dali::Actor *)jarg2;
41927   if (!arg2) {
41928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
41929     return ;
41930   }
41931   arg3 = (int)jarg3;
41932   arg4 = (Dali::Vector3 *)jarg4;
41933   if (!arg4) {
41934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
41935     return ;
41936   }
41937   arg5 = (Dali::Actor *)jarg5;
41938   if (!arg5) {
41939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
41940     return ;
41941   }
41942   {
41943     try {
41944       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
41945     } CALL_CATCH_EXCEPTION();
41946   }
41947
41948 }
41949
41950
41951 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
41952   void * jresult ;
41953   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41954   int arg2 ;
41955   float arg3 ;
41956   Dali::Vector3 *arg4 = 0 ;
41957   Dali::Vector3 result;
41958
41959   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41960   arg2 = (int)jarg2;
41961   arg3 = (float)jarg3;
41962   arg4 = (Dali::Vector3 *)jarg4;
41963   if (!arg4) {
41964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
41965     return 0;
41966   }
41967   {
41968     try {
41969       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
41970     } CALL_CATCH_EXCEPTION(0);
41971   }
41972
41973   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
41974   return jresult;
41975 }
41976
41977
41978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
41979   void * jresult ;
41980   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
41981   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
41982
41983   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
41984   {
41985     try {
41986       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
41987     } CALL_CATCH_EXCEPTION(0);
41988   }
41989
41990   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
41991   return jresult;
41992 }
41993
41994
41995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
41996   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
41997
41998   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
41999   {
42000     try {
42001       delete arg1;
42002     } CALL_CATCH_EXCEPTION();
42003   }
42004
42005 }
42006
42007
42008 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
42009   unsigned int jresult ;
42010   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
42011   unsigned int result;
42012
42013   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
42014   {
42015     try {
42016       result = (unsigned int)(arg1)->GetNumberOfItems();
42017     } CALL_CATCH_EXCEPTION(0);
42018   }
42019
42020   jresult = result;
42021   return jresult;
42022 }
42023
42024
42025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
42026   void * jresult ;
42027   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
42028   unsigned int arg2 ;
42029   Dali::Actor result;
42030
42031   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
42032   arg2 = (unsigned int)jarg2;
42033   {
42034     try {
42035       result = (arg1)->NewItem(arg2);
42036     } CALL_CATCH_EXCEPTION(0);
42037   }
42038
42039   jresult = new Dali::Actor((const Dali::Actor &)result);
42040   return jresult;
42041 }
42042
42043
42044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
42045   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
42046   unsigned int arg2 ;
42047   Dali::Actor arg3 ;
42048   Dali::Actor *argp3 ;
42049
42050   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
42051   arg2 = (unsigned int)jarg2;
42052   argp3 = (Dali::Actor *)jarg3;
42053   if (!argp3) {
42054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
42055     return ;
42056   }
42057   arg3 = *argp3;
42058   {
42059     try {
42060       (arg1)->ItemReleased(arg2,arg3);
42061     } CALL_CATCH_EXCEPTION();
42062   }
42063
42064 }
42065
42066
42067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
42068   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
42069   unsigned int arg2 ;
42070   Dali::Actor arg3 ;
42071   Dali::Actor *argp3 ;
42072
42073   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
42074   arg2 = (unsigned int)jarg2;
42075   argp3 = (Dali::Actor *)jarg3;
42076   if (!argp3) {
42077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
42078     return ;
42079   }
42080   arg3 = *argp3;
42081   {
42082     try {
42083       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
42084     } CALL_CATCH_EXCEPTION();
42085   }
42086
42087 }
42088
42089
42090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
42091   void * jresult ;
42092   Dali::Toolkit::ItemFactory *result = 0 ;
42093
42094   {
42095     try {
42096       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
42097     } CALL_CATCH_EXCEPTION(0);
42098   }
42099
42100   jresult = (void *)result;
42101   return jresult;
42102 }
42103
42104
42105 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) {
42106   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
42107   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
42108   if (director) {
42109     director->swig_connect_director(callback0, callback1, callback2);
42110   }
42111 }
42112
42113
42114 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
42115   int jresult ;
42116   int result;
42117
42118   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
42119   jresult = (int)result;
42120   return jresult;
42121 }
42122
42123
42124 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
42125   int jresult ;
42126   int result;
42127
42128   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
42129   jresult = (int)result;
42130   return jresult;
42131 }
42132
42133
42134 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
42135   int jresult ;
42136   int result;
42137
42138   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
42139   jresult = (int)result;
42140   return jresult;
42141 }
42142
42143
42144 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
42145   int jresult ;
42146   int result;
42147
42148   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
42149   jresult = (int)result;
42150   return jresult;
42151 }
42152
42153
42154 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
42155   int jresult ;
42156   int result;
42157
42158   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
42159   jresult = (int)result;
42160   return jresult;
42161 }
42162
42163
42164 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
42165   int jresult ;
42166   int result;
42167
42168   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
42169   jresult = (int)result;
42170   return jresult;
42171 }
42172
42173
42174 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
42175   int jresult ;
42176   int result;
42177
42178   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
42179   jresult = (int)result;
42180   return jresult;
42181 }
42182
42183
42184 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
42185   int jresult ;
42186   int result;
42187
42188   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
42189   jresult = (int)result;
42190   return jresult;
42191 }
42192
42193
42194 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
42195   int jresult ;
42196   int result;
42197
42198   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
42199   jresult = (int)result;
42200   return jresult;
42201 }
42202
42203
42204 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
42205   int jresult ;
42206   int result;
42207
42208   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
42209   jresult = (int)result;
42210   return jresult;
42211 }
42212
42213
42214 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
42215   int jresult ;
42216   int result;
42217
42218   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
42219   jresult = (int)result;
42220   return jresult;
42221 }
42222
42223
42224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
42225   void * jresult ;
42226   Dali::Toolkit::ItemView::Property *result = 0 ;
42227
42228   {
42229     try {
42230       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
42231     } CALL_CATCH_EXCEPTION(0);
42232   }
42233
42234   jresult = (void *)result;
42235   return jresult;
42236 }
42237
42238
42239 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
42240   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
42241
42242   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
42243   {
42244     try {
42245       delete arg1;
42246     } CALL_CATCH_EXCEPTION();
42247   }
42248
42249 }
42250
42251
42252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
42253   void * jresult ;
42254   Dali::Toolkit::ItemView *result = 0 ;
42255
42256   {
42257     try {
42258       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
42259     } CALL_CATCH_EXCEPTION(0);
42260   }
42261
42262   jresult = (void *)result;
42263   return jresult;
42264 }
42265
42266
42267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
42268   void * jresult ;
42269   Dali::Toolkit::ItemView *arg1 = 0 ;
42270   Dali::Toolkit::ItemView *result = 0 ;
42271
42272   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42273   if (!arg1) {
42274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
42275     return 0;
42276   }
42277   {
42278     try {
42279       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
42280     } CALL_CATCH_EXCEPTION(0);
42281   }
42282
42283   jresult = (void *)result;
42284   return jresult;
42285 }
42286
42287
42288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
42289   void * jresult ;
42290   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42291   Dali::Toolkit::ItemView *arg2 = 0 ;
42292   Dali::Toolkit::ItemView *result = 0 ;
42293
42294   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42295   arg2 = (Dali::Toolkit::ItemView *)jarg2;
42296   if (!arg2) {
42297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
42298     return 0;
42299   }
42300   {
42301     try {
42302       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
42303     } CALL_CATCH_EXCEPTION(0);
42304   }
42305
42306   jresult = (void *)result;
42307   return jresult;
42308 }
42309
42310
42311 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
42312   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42313
42314   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42315   {
42316     try {
42317       delete arg1;
42318     } CALL_CATCH_EXCEPTION();
42319   }
42320
42321 }
42322
42323
42324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
42325   void * jresult ;
42326   Dali::Toolkit::ItemFactory *arg1 = 0 ;
42327   Dali::Toolkit::ItemView result;
42328
42329   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
42330   if (!arg1) {
42331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
42332     return 0;
42333   }
42334   {
42335     try {
42336       result = Dali::Toolkit::ItemView::New(*arg1);
42337     } CALL_CATCH_EXCEPTION(0);
42338   }
42339
42340   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
42341   return jresult;
42342 }
42343
42344
42345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
42346   void * jresult ;
42347   Dali::BaseHandle arg1 ;
42348   Dali::BaseHandle *argp1 ;
42349   Dali::Toolkit::ItemView result;
42350
42351   argp1 = (Dali::BaseHandle *)jarg1;
42352   if (!argp1) {
42353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42354     return 0;
42355   }
42356   arg1 = *argp1;
42357   {
42358     try {
42359       result = Dali::Toolkit::ItemView::DownCast(arg1);
42360     } CALL_CATCH_EXCEPTION(0);
42361   }
42362
42363   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
42364   return jresult;
42365 }
42366
42367
42368 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
42369   unsigned int jresult ;
42370   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42371   unsigned int result;
42372
42373   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42374   {
42375     try {
42376       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
42377     } CALL_CATCH_EXCEPTION(0);
42378   }
42379
42380   jresult = result;
42381   return jresult;
42382 }
42383
42384
42385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
42386   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42387   Dali::Toolkit::ItemLayout *arg2 = 0 ;
42388
42389   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42390   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
42391   if (!arg2) {
42392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
42393     return ;
42394   }
42395   {
42396     try {
42397       (arg1)->AddLayout(*arg2);
42398     } CALL_CATCH_EXCEPTION();
42399   }
42400
42401 }
42402
42403
42404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
42405   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42406   unsigned int arg2 ;
42407
42408   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42409   arg2 = (unsigned int)jarg2;
42410   {
42411     try {
42412       (arg1)->RemoveLayout(arg2);
42413     } CALL_CATCH_EXCEPTION();
42414   }
42415
42416 }
42417
42418
42419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
42420   void * jresult ;
42421   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42422   unsigned int arg2 ;
42423   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
42424
42425   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42426   arg2 = (unsigned int)jarg2;
42427   {
42428     try {
42429       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
42430     } CALL_CATCH_EXCEPTION(0);
42431   }
42432
42433   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
42434   return jresult;
42435 }
42436
42437
42438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
42439   void * jresult ;
42440   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42441   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
42442
42443   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42444   {
42445     try {
42446       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
42447     } CALL_CATCH_EXCEPTION(0);
42448   }
42449
42450   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
42451   return jresult;
42452 }
42453
42454
42455 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
42456   float jresult ;
42457   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42458   Dali::Toolkit::ItemId arg2 ;
42459   float result;
42460
42461   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42462   arg2 = (Dali::Toolkit::ItemId)jarg2;
42463   {
42464     try {
42465       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
42466     } CALL_CATCH_EXCEPTION(0);
42467   }
42468
42469   jresult = result;
42470   return jresult;
42471 }
42472
42473
42474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
42475   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42476   unsigned int arg2 ;
42477   Dali::Vector3 arg3 ;
42478   float arg4 ;
42479   Dali::Vector3 *argp3 ;
42480
42481   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42482   arg2 = (unsigned int)jarg2;
42483   argp3 = (Dali::Vector3 *)jarg3;
42484   if (!argp3) {
42485     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
42486     return ;
42487   }
42488   arg3 = *argp3;
42489   arg4 = (float)jarg4;
42490   {
42491     try {
42492       (arg1)->ActivateLayout(arg2,arg3,arg4);
42493     } CALL_CATCH_EXCEPTION();
42494   }
42495
42496 }
42497
42498
42499 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
42500   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42501
42502   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42503   {
42504     try {
42505       (arg1)->DeactivateCurrentLayout();
42506     } CALL_CATCH_EXCEPTION();
42507   }
42508
42509 }
42510
42511
42512 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
42513   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42514   float arg2 ;
42515
42516   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42517   arg2 = (float)jarg2;
42518   {
42519     try {
42520       (arg1)->SetMinimumSwipeSpeed(arg2);
42521     } CALL_CATCH_EXCEPTION();
42522   }
42523
42524 }
42525
42526
42527 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
42528   float jresult ;
42529   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42530   float result;
42531
42532   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42533   {
42534     try {
42535       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
42536     } CALL_CATCH_EXCEPTION(0);
42537   }
42538
42539   jresult = result;
42540   return jresult;
42541 }
42542
42543
42544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
42545   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42546   float arg2 ;
42547
42548   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42549   arg2 = (float)jarg2;
42550   {
42551     try {
42552       (arg1)->SetMinimumSwipeDistance(arg2);
42553     } CALL_CATCH_EXCEPTION();
42554   }
42555
42556 }
42557
42558
42559 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
42560   float jresult ;
42561   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42562   float result;
42563
42564   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42565   {
42566     try {
42567       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
42568     } CALL_CATCH_EXCEPTION(0);
42569   }
42570
42571   jresult = result;
42572   return jresult;
42573 }
42574
42575
42576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
42577   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42578   float arg2 ;
42579
42580   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42581   arg2 = (float)jarg2;
42582   {
42583     try {
42584       (arg1)->SetWheelScrollDistanceStep(arg2);
42585     } CALL_CATCH_EXCEPTION();
42586   }
42587
42588 }
42589
42590
42591 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
42592   float jresult ;
42593   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42594   float result;
42595
42596   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42597   {
42598     try {
42599       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
42600     } CALL_CATCH_EXCEPTION(0);
42601   }
42602
42603   jresult = result;
42604   return jresult;
42605 }
42606
42607
42608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
42609   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42610   bool arg2 ;
42611
42612   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42613   arg2 = jarg2 ? true : false;
42614   {
42615     try {
42616       (arg1)->SetAnchoring(arg2);
42617     } CALL_CATCH_EXCEPTION();
42618   }
42619
42620 }
42621
42622 //// ========================= end of part 3 =============================
42623
42624 //// ========================== start part 4 ===============================
42625
42626
42627 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
42628   unsigned int jresult ;
42629   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42630   bool result;
42631
42632   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42633   {
42634     try {
42635       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
42636     } CALL_CATCH_EXCEPTION(0);
42637   }
42638
42639   jresult = result;
42640   return jresult;
42641 }
42642
42643
42644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
42645   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42646   float arg2 ;
42647
42648   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42649   arg2 = (float)jarg2;
42650   {
42651     try {
42652       (arg1)->SetAnchoringDuration(arg2);
42653     } CALL_CATCH_EXCEPTION();
42654   }
42655
42656 }
42657
42658
42659 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
42660   float jresult ;
42661   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42662   float result;
42663
42664   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42665   {
42666     try {
42667       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
42668     } CALL_CATCH_EXCEPTION(0);
42669   }
42670
42671   jresult = result;
42672   return jresult;
42673 }
42674
42675
42676 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
42677   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42678   Dali::Toolkit::ItemId arg2 ;
42679   float arg3 ;
42680
42681   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42682   arg2 = (Dali::Toolkit::ItemId)jarg2;
42683   arg3 = (float)jarg3;
42684   {
42685     try {
42686       (arg1)->ScrollToItem(arg2,arg3);
42687     } CALL_CATCH_EXCEPTION();
42688   }
42689
42690 }
42691
42692
42693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
42694   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42695   float arg2 ;
42696
42697   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42698   arg2 = (float)jarg2;
42699   {
42700     try {
42701       (arg1)->SetRefreshInterval(arg2);
42702     } CALL_CATCH_EXCEPTION();
42703   }
42704
42705 }
42706
42707
42708 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
42709   float jresult ;
42710   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42711   float result;
42712
42713   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42714   {
42715     try {
42716       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
42717     } CALL_CATCH_EXCEPTION(0);
42718   }
42719
42720   jresult = result;
42721   return jresult;
42722 }
42723
42724
42725 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
42726   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42727
42728   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42729   {
42730     try {
42731       (arg1)->Refresh();
42732     } CALL_CATCH_EXCEPTION();
42733   }
42734
42735 }
42736
42737
42738 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
42739   void * jresult ;
42740   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42741   Dali::Toolkit::ItemId arg2 ;
42742   Dali::Actor result;
42743
42744   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42745   arg2 = (Dali::Toolkit::ItemId)jarg2;
42746   {
42747     try {
42748       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
42749     } CALL_CATCH_EXCEPTION(0);
42750   }
42751
42752   jresult = new Dali::Actor((const Dali::Actor &)result);
42753   return jresult;
42754 }
42755
42756
42757 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
42758   unsigned int jresult ;
42759   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42760   Dali::Actor arg2 ;
42761   Dali::Actor *argp2 ;
42762   Dali::Toolkit::ItemId result;
42763
42764   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42765   argp2 = (Dali::Actor *)jarg2;
42766   if (!argp2) {
42767     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
42768     return 0;
42769   }
42770   arg2 = *argp2;
42771   {
42772     try {
42773       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
42774     } CALL_CATCH_EXCEPTION(0);
42775   }
42776
42777   jresult = result;
42778   return jresult;
42779 }
42780
42781
42782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
42783   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42784   Dali::Toolkit::Item arg2 ;
42785   float arg3 ;
42786   Dali::Toolkit::Item *argp2 ;
42787
42788   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42789   argp2 = (Dali::Toolkit::Item *)jarg2;
42790   if (!argp2) {
42791     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
42792     return ;
42793   }
42794   arg2 = *argp2;
42795   arg3 = (float)jarg3;
42796   {
42797     try {
42798       (arg1)->InsertItem(arg2,arg3);
42799     } CALL_CATCH_EXCEPTION();
42800   }
42801
42802 }
42803
42804
42805 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
42806   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42807   Dali::Toolkit::ItemContainer *arg2 = 0 ;
42808   float arg3 ;
42809
42810   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42811   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
42812   if (!arg2) {
42813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
42814     return ;
42815   }
42816   arg3 = (float)jarg3;
42817   {
42818     try {
42819       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
42820     } CALL_CATCH_EXCEPTION();
42821   }
42822
42823 }
42824
42825
42826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
42827   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42828   Dali::Toolkit::ItemId arg2 ;
42829   float arg3 ;
42830
42831   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42832   arg2 = (Dali::Toolkit::ItemId)jarg2;
42833   arg3 = (float)jarg3;
42834   {
42835     try {
42836       (arg1)->RemoveItem(arg2,arg3);
42837     } CALL_CATCH_EXCEPTION();
42838   }
42839
42840 }
42841
42842
42843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
42844   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42845   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
42846   float arg3 ;
42847
42848   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42849   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
42850   if (!arg2) {
42851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
42852     return ;
42853   }
42854   arg3 = (float)jarg3;
42855   {
42856     try {
42857       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
42858     } CALL_CATCH_EXCEPTION();
42859   }
42860
42861 }
42862
42863
42864 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
42865   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42866   Dali::Toolkit::Item arg2 ;
42867   float arg3 ;
42868   Dali::Toolkit::Item *argp2 ;
42869
42870   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42871   argp2 = (Dali::Toolkit::Item *)jarg2;
42872   if (!argp2) {
42873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
42874     return ;
42875   }
42876   arg2 = *argp2;
42877   arg3 = (float)jarg3;
42878   {
42879     try {
42880       (arg1)->ReplaceItem(arg2,arg3);
42881     } CALL_CATCH_EXCEPTION();
42882   }
42883
42884 }
42885
42886
42887 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
42888   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42889   Dali::Toolkit::ItemContainer *arg2 = 0 ;
42890   float arg3 ;
42891
42892   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42893   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
42894   if (!arg2) {
42895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
42896     return ;
42897   }
42898   arg3 = (float)jarg3;
42899   {
42900     try {
42901       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
42902     } CALL_CATCH_EXCEPTION();
42903   }
42904
42905 }
42906
42907
42908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
42909   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42910   Dali::Vector3 *arg2 = 0 ;
42911
42912   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42913   arg2 = (Dali::Vector3 *)jarg2;
42914   if (!arg2) {
42915     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
42916     return ;
42917   }
42918   {
42919     try {
42920       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
42921     } CALL_CATCH_EXCEPTION();
42922   }
42923
42924 }
42925
42926
42927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
42928   void * jresult ;
42929   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42930   Dali::Vector3 result;
42931
42932   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42933   {
42934     try {
42935       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
42936     } CALL_CATCH_EXCEPTION(0);
42937   }
42938
42939   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
42940   return jresult;
42941 }
42942
42943
42944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
42945   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42946   Dali::Vector3 *arg2 = 0 ;
42947
42948   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42949   arg2 = (Dali::Vector3 *)jarg2;
42950   if (!arg2) {
42951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
42952     return ;
42953   }
42954   {
42955     try {
42956       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
42957     } CALL_CATCH_EXCEPTION();
42958   }
42959
42960 }
42961
42962
42963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
42964   void * jresult ;
42965   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42966   Dali::Vector3 result;
42967
42968   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42969   {
42970     try {
42971       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
42972     } CALL_CATCH_EXCEPTION(0);
42973   }
42974
42975   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
42976   return jresult;
42977 }
42978
42979
42980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
42981   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42982   Dali::Toolkit::ItemRange *arg2 = 0 ;
42983
42984   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42985   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
42986   if (!arg2) {
42987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
42988     return ;
42989   }
42990   {
42991     try {
42992       (arg1)->GetItemsRange(*arg2);
42993     } CALL_CATCH_EXCEPTION();
42994   }
42995
42996 }
42997
42998
42999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
43000   void * jresult ;
43001   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
43002   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
43003
43004   arg1 = (Dali::Toolkit::ItemView *)jarg1;
43005   {
43006     try {
43007       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
43008     } CALL_CATCH_EXCEPTION(0);
43009   }
43010
43011   jresult = (void *)result;
43012   return jresult;
43013 }
43014
43015
43016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
43017   Dali::Vector3 *arg1 = 0 ;
43018   PropertyInputContainer *arg2 = 0 ;
43019
43020   arg1 = (Dali::Vector3 *)jarg1;
43021   if (!arg1) {
43022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43023     return ;
43024   }
43025   arg2 = (PropertyInputContainer *)jarg2;
43026   if (!arg2) {
43027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
43028     return ;
43029   }
43030   {
43031     try {
43032       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
43033     } CALL_CATCH_EXCEPTION();
43034   }
43035
43036 }
43037
43038
43039 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
43040   Dali::Vector3 *arg1 = 0 ;
43041   PropertyInputContainer *arg2 = 0 ;
43042
43043   arg1 = (Dali::Vector3 *)jarg1;
43044   if (!arg1) {
43045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43046     return ;
43047   }
43048   arg2 = (PropertyInputContainer *)jarg2;
43049   if (!arg2) {
43050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
43051     return ;
43052   }
43053   {
43054     try {
43055       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
43056     } CALL_CATCH_EXCEPTION();
43057   }
43058
43059 }
43060
43061
43062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
43063   void * jresult ;
43064   Dali::Toolkit::ScrollViewEffect *result = 0 ;
43065
43066   {
43067     try {
43068       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
43069     } CALL_CATCH_EXCEPTION(0);
43070   }
43071
43072   jresult = (void *)result;
43073   return jresult;
43074 }
43075
43076
43077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
43078   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
43079
43080   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
43081   {
43082     try {
43083       delete arg1;
43084     } CALL_CATCH_EXCEPTION();
43085   }
43086
43087 }
43088
43089
43090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
43091   void * jresult ;
43092   Dali::Path arg1 ;
43093   Dali::Vector3 *arg2 = 0 ;
43094   Dali::Property::Index arg3 ;
43095   Dali::Vector3 *arg4 = 0 ;
43096   unsigned int arg5 ;
43097   Dali::Path *argp1 ;
43098   Dali::Toolkit::ScrollViewPagePathEffect result;
43099
43100   argp1 = (Dali::Path *)jarg1;
43101   if (!argp1) {
43102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
43103     return 0;
43104   }
43105   arg1 = *argp1;
43106   arg2 = (Dali::Vector3 *)jarg2;
43107   if (!arg2) {
43108     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43109     return 0;
43110   }
43111   arg3 = (Dali::Property::Index)jarg3;
43112   arg4 = (Dali::Vector3 *)jarg4;
43113   if (!arg4) {
43114     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43115     return 0;
43116   }
43117   arg5 = (unsigned int)jarg5;
43118   {
43119     try {
43120       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
43121     } CALL_CATCH_EXCEPTION(0);
43122   }
43123
43124   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
43125   return jresult;
43126 }
43127
43128
43129 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
43130   void * jresult ;
43131   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
43132
43133   {
43134     try {
43135       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
43136     } CALL_CATCH_EXCEPTION(0);
43137   }
43138
43139   jresult = (void *)result;
43140   return jresult;
43141 }
43142
43143
43144 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
43145   void * jresult ;
43146   Dali::BaseHandle arg1 ;
43147   Dali::BaseHandle *argp1 ;
43148   Dali::Toolkit::ScrollViewPagePathEffect result;
43149
43150   argp1 = (Dali::BaseHandle *)jarg1;
43151   if (!argp1) {
43152     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43153     return 0;
43154   }
43155   arg1 = *argp1;
43156   {
43157     try {
43158       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
43159     } CALL_CATCH_EXCEPTION(0);
43160   }
43161
43162   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
43163   return jresult;
43164 }
43165
43166
43167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
43168   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
43169   Dali::Actor arg2 ;
43170   unsigned int arg3 ;
43171   Dali::Actor *argp2 ;
43172
43173   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
43174   argp2 = (Dali::Actor *)jarg2;
43175   if (!argp2) {
43176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
43177     return ;
43178   }
43179   arg2 = *argp2;
43180   arg3 = (unsigned int)jarg3;
43181   {
43182     try {
43183       (arg1)->ApplyToPage(arg2,arg3);
43184     } CALL_CATCH_EXCEPTION();
43185   }
43186
43187 }
43188
43189
43190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
43191   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
43192
43193   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
43194   {
43195     try {
43196       delete arg1;
43197     } CALL_CATCH_EXCEPTION();
43198   }
43199
43200 }
43201
43202
43203 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
43204   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
43205   Dali::Toolkit::ClampState arg2 ;
43206
43207   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
43208   arg2 = (Dali::Toolkit::ClampState)jarg2;
43209   if (arg1) (arg1)->x = arg2;
43210 }
43211
43212
43213 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
43214   int jresult ;
43215   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
43216   Dali::Toolkit::ClampState result;
43217
43218   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
43219   result = (Dali::Toolkit::ClampState) ((arg1)->x);
43220   jresult = (int)result;
43221   return jresult;
43222 }
43223
43224
43225 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
43226   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
43227   Dali::Toolkit::ClampState arg2 ;
43228
43229   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
43230   arg2 = (Dali::Toolkit::ClampState)jarg2;
43231   if (arg1) (arg1)->y = arg2;
43232 }
43233
43234
43235 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
43236   int jresult ;
43237   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
43238   Dali::Toolkit::ClampState result;
43239
43240   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
43241   result = (Dali::Toolkit::ClampState) ((arg1)->y);
43242   jresult = (int)result;
43243   return jresult;
43244 }
43245
43246
43247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
43248   void * jresult ;
43249   Dali::Toolkit::ClampState2D *result = 0 ;
43250
43251   {
43252     try {
43253       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
43254     } CALL_CATCH_EXCEPTION(0);
43255   }
43256
43257   jresult = (void *)result;
43258   return jresult;
43259 }
43260
43261
43262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
43263   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
43264
43265   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
43266   {
43267     try {
43268       delete arg1;
43269     } CALL_CATCH_EXCEPTION();
43270   }
43271
43272 }
43273
43274
43275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
43276   void * jresult ;
43277   float arg1 ;
43278   float arg2 ;
43279   bool arg3 ;
43280   Dali::Toolkit::RulerDomain *result = 0 ;
43281
43282   arg1 = (float)jarg1;
43283   arg2 = (float)jarg2;
43284   arg3 = jarg3 ? true : false;
43285   {
43286     try {
43287       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
43288     } CALL_CATCH_EXCEPTION(0);
43289   }
43290
43291   jresult = (void *)result;
43292   return jresult;
43293 }
43294
43295
43296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
43297   void * jresult ;
43298   float arg1 ;
43299   float arg2 ;
43300   Dali::Toolkit::RulerDomain *result = 0 ;
43301
43302   arg1 = (float)jarg1;
43303   arg2 = (float)jarg2;
43304   {
43305     try {
43306       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
43307     } CALL_CATCH_EXCEPTION(0);
43308   }
43309
43310   jresult = (void *)result;
43311   return jresult;
43312 }
43313
43314
43315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
43316   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
43317   float arg2 ;
43318
43319   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
43320   arg2 = (float)jarg2;
43321   if (arg1) (arg1)->min = arg2;
43322 }
43323
43324
43325 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
43326   float jresult ;
43327   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
43328   float result;
43329
43330   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
43331   result = (float) ((arg1)->min);
43332   jresult = result;
43333   return jresult;
43334 }
43335
43336
43337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
43338   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
43339   float arg2 ;
43340
43341   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
43342   arg2 = (float)jarg2;
43343   if (arg1) (arg1)->max = arg2;
43344 }
43345
43346
43347 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
43348   float jresult ;
43349   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
43350   float result;
43351
43352   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
43353   result = (float) ((arg1)->max);
43354   jresult = result;
43355   return jresult;
43356 }
43357
43358
43359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
43360   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
43361   bool arg2 ;
43362
43363   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
43364   arg2 = jarg2 ? true : false;
43365   if (arg1) (arg1)->enabled = arg2;
43366 }
43367
43368
43369 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
43370   unsigned int jresult ;
43371   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
43372   bool result;
43373
43374   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
43375   result = (bool) ((arg1)->enabled);
43376   jresult = result;
43377   return jresult;
43378 }
43379
43380
43381 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
43382   float jresult ;
43383   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
43384   float arg2 ;
43385   float arg3 ;
43386   float arg4 ;
43387   float result;
43388
43389   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
43390   arg2 = (float)jarg2;
43391   arg3 = (float)jarg3;
43392   arg4 = (float)jarg4;
43393   {
43394     try {
43395       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
43396     } CALL_CATCH_EXCEPTION(0);
43397   }
43398
43399   jresult = result;
43400   return jresult;
43401 }
43402
43403
43404 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
43405   float jresult ;
43406   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
43407   float arg2 ;
43408   float arg3 ;
43409   float result;
43410
43411   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
43412   arg2 = (float)jarg2;
43413   arg3 = (float)jarg3;
43414   {
43415     try {
43416       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
43417     } CALL_CATCH_EXCEPTION(0);
43418   }
43419
43420   jresult = result;
43421   return jresult;
43422 }
43423
43424
43425 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
43426   float jresult ;
43427   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
43428   float arg2 ;
43429   float result;
43430
43431   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
43432   arg2 = (float)jarg2;
43433   {
43434     try {
43435       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
43436     } CALL_CATCH_EXCEPTION(0);
43437   }
43438
43439   jresult = result;
43440   return jresult;
43441 }
43442
43443
43444 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
43445   float jresult ;
43446   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
43447   float arg2 ;
43448   float arg3 ;
43449   float arg4 ;
43450   Dali::Toolkit::ClampState *arg5 = 0 ;
43451   float result;
43452
43453   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
43454   arg2 = (float)jarg2;
43455   arg3 = (float)jarg3;
43456   arg4 = (float)jarg4;
43457   arg5 = (Dali::Toolkit::ClampState *)jarg5;
43458   if (!arg5) {
43459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
43460     return 0;
43461   }
43462   {
43463     try {
43464       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
43465     } CALL_CATCH_EXCEPTION(0);
43466   }
43467
43468   jresult = result;
43469   return jresult;
43470 }
43471
43472
43473 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
43474   float jresult ;
43475   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
43476   float result;
43477
43478   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
43479   {
43480     try {
43481       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
43482     } CALL_CATCH_EXCEPTION(0);
43483   }
43484
43485   jresult = result;
43486   return jresult;
43487 }
43488
43489
43490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
43491   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
43492
43493   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
43494   {
43495     try {
43496       delete arg1;
43497     } CALL_CATCH_EXCEPTION();
43498   }
43499
43500 }
43501
43502
43503 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
43504   float jresult ;
43505   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43506   float arg2 ;
43507   float arg3 ;
43508   float result;
43509
43510   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43511   arg2 = (float)jarg2;
43512   arg3 = (float)jarg3;
43513   {
43514     try {
43515       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
43516     } CALL_CATCH_EXCEPTION(0);
43517   }
43518
43519   jresult = result;
43520   return jresult;
43521 }
43522
43523
43524 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
43525   float jresult ;
43526   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43527   float arg2 ;
43528   float result;
43529
43530   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43531   arg2 = (float)jarg2;
43532   {
43533     try {
43534       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
43535     } CALL_CATCH_EXCEPTION(0);
43536   }
43537
43538   jresult = result;
43539   return jresult;
43540 }
43541
43542
43543 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
43544   float jresult ;
43545   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43546   unsigned int arg2 ;
43547   unsigned int *arg3 = 0 ;
43548   bool arg4 ;
43549   float result;
43550
43551   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43552   arg2 = (unsigned int)jarg2;
43553   arg3 = (unsigned int *)jarg3;
43554   arg4 = jarg4 ? true : false;
43555   {
43556     try {
43557       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
43558     } CALL_CATCH_EXCEPTION(0);
43559   }
43560
43561   jresult = result;
43562   return jresult;
43563 }
43564
43565
43566 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
43567   unsigned int jresult ;
43568   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43569   float arg2 ;
43570   bool arg3 ;
43571   unsigned int result;
43572
43573   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43574   arg2 = (float)jarg2;
43575   arg3 = jarg3 ? true : false;
43576   {
43577     try {
43578       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
43579     } CALL_CATCH_EXCEPTION(0);
43580   }
43581
43582   jresult = result;
43583   return jresult;
43584 }
43585
43586
43587 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
43588   unsigned int jresult ;
43589   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43590   unsigned int result;
43591
43592   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43593   {
43594     try {
43595       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
43596     } CALL_CATCH_EXCEPTION(0);
43597   }
43598
43599   jresult = result;
43600   return jresult;
43601 }
43602
43603
43604 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
43605   int jresult ;
43606   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43607   Dali::Toolkit::Ruler::RulerType result;
43608
43609   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43610   {
43611     try {
43612       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
43613     } CALL_CATCH_EXCEPTION(0);
43614   }
43615
43616   jresult = (int)result;
43617   return jresult;
43618 }
43619
43620
43621 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
43622   unsigned int jresult ;
43623   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43624   bool result;
43625
43626   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43627   {
43628     try {
43629       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
43630     } CALL_CATCH_EXCEPTION(0);
43631   }
43632
43633   jresult = result;
43634   return jresult;
43635 }
43636
43637
43638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
43639   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43640
43641   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43642   {
43643     try {
43644       (arg1)->Enable();
43645     } CALL_CATCH_EXCEPTION();
43646   }
43647
43648 }
43649
43650
43651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
43652   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43653
43654   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43655   {
43656     try {
43657       (arg1)->Disable();
43658     } CALL_CATCH_EXCEPTION();
43659   }
43660
43661 }
43662
43663
43664 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
43665   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43666   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
43667   Dali::Toolkit::RulerDomain *argp2 ;
43668
43669   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43670   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
43671   if (!argp2) {
43672     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
43673     return ;
43674   }
43675   arg2 = *argp2;
43676   {
43677     try {
43678       (arg1)->SetDomain(arg2);
43679     } CALL_CATCH_EXCEPTION();
43680   }
43681
43682 }
43683
43684
43685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
43686   void * jresult ;
43687   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43688   Dali::Toolkit::RulerDomain *result = 0 ;
43689
43690   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43691   {
43692     try {
43693       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
43694     } CALL_CATCH_EXCEPTION(0);
43695   }
43696
43697   jresult = (void *)result;
43698   return jresult;
43699 }
43700
43701
43702 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
43703   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43704
43705   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43706   {
43707     try {
43708       (arg1)->DisableDomain();
43709     } CALL_CATCH_EXCEPTION();
43710   }
43711
43712 }
43713
43714
43715 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
43716   float jresult ;
43717   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43718   float arg2 ;
43719   float arg3 ;
43720   float arg4 ;
43721   float result;
43722
43723   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43724   arg2 = (float)jarg2;
43725   arg3 = (float)jarg3;
43726   arg4 = (float)jarg4;
43727   {
43728     try {
43729       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
43730     } CALL_CATCH_EXCEPTION(0);
43731   }
43732
43733   jresult = result;
43734   return jresult;
43735 }
43736
43737
43738 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
43739   float jresult ;
43740   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43741   float arg2 ;
43742   float arg3 ;
43743   float result;
43744
43745   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43746   arg2 = (float)jarg2;
43747   arg3 = (float)jarg3;
43748   {
43749     try {
43750       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
43751     } CALL_CATCH_EXCEPTION(0);
43752   }
43753
43754   jresult = result;
43755   return jresult;
43756 }
43757
43758
43759 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
43760   float jresult ;
43761   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43762   float arg2 ;
43763   float result;
43764
43765   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43766   arg2 = (float)jarg2;
43767   {
43768     try {
43769       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
43770     } CALL_CATCH_EXCEPTION(0);
43771   }
43772
43773   jresult = result;
43774   return jresult;
43775 }
43776
43777
43778 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
43779   float jresult ;
43780   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43781   float arg2 ;
43782   float arg3 ;
43783   float arg4 ;
43784   Dali::Toolkit::ClampState *arg5 = 0 ;
43785   float result;
43786
43787   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43788   arg2 = (float)jarg2;
43789   arg3 = (float)jarg3;
43790   arg4 = (float)jarg4;
43791   arg5 = (Dali::Toolkit::ClampState *)jarg5;
43792   if (!arg5) {
43793     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
43794     return 0;
43795   }
43796   {
43797     try {
43798       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
43799     } CALL_CATCH_EXCEPTION(0);
43800   }
43801
43802   jresult = result;
43803   return jresult;
43804 }
43805
43806
43807 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
43808   float jresult ;
43809   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43810   float arg2 ;
43811   float arg3 ;
43812   float arg4 ;
43813   float arg5 ;
43814   float result;
43815
43816   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43817   arg2 = (float)jarg2;
43818   arg3 = (float)jarg3;
43819   arg4 = (float)jarg4;
43820   arg5 = (float)jarg5;
43821   {
43822     try {
43823       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
43824     } CALL_CATCH_EXCEPTION(0);
43825   }
43826
43827   jresult = result;
43828   return jresult;
43829 }
43830
43831
43832 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
43833   float jresult ;
43834   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43835   float arg2 ;
43836   float arg3 ;
43837   float arg4 ;
43838   float result;
43839
43840   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43841   arg2 = (float)jarg2;
43842   arg3 = (float)jarg3;
43843   arg4 = (float)jarg4;
43844   {
43845     try {
43846       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
43847     } CALL_CATCH_EXCEPTION(0);
43848   }
43849
43850   jresult = result;
43851   return jresult;
43852 }
43853
43854
43855 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
43856   float jresult ;
43857   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43858   float arg2 ;
43859   float arg3 ;
43860   float result;
43861
43862   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43863   arg2 = (float)jarg2;
43864   arg3 = (float)jarg3;
43865   {
43866     try {
43867       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
43868     } CALL_CATCH_EXCEPTION(0);
43869   }
43870
43871   jresult = result;
43872   return jresult;
43873 }
43874
43875
43876 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
43877   float jresult ;
43878   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43879   float arg2 ;
43880   float result;
43881
43882   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43883   arg2 = (float)jarg2;
43884   {
43885     try {
43886       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
43887     } CALL_CATCH_EXCEPTION(0);
43888   }
43889
43890   jresult = result;
43891   return jresult;
43892 }
43893
43894
43895 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
43896   float jresult ;
43897   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43898   float arg2 ;
43899   float arg3 ;
43900   float arg4 ;
43901   float arg5 ;
43902   Dali::Toolkit::ClampState *arg6 = 0 ;
43903   float result;
43904
43905   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43906   arg2 = (float)jarg2;
43907   arg3 = (float)jarg3;
43908   arg4 = (float)jarg4;
43909   arg5 = (float)jarg5;
43910   arg6 = (Dali::Toolkit::ClampState *)jarg6;
43911   if (!arg6) {
43912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
43913     return 0;
43914   }
43915   {
43916     try {
43917       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
43918     } CALL_CATCH_EXCEPTION(0);
43919   }
43920
43921   jresult = result;
43922   return jresult;
43923 }
43924
43925
43926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
43927   void * jresult ;
43928   Dali::Toolkit::DefaultRuler *result = 0 ;
43929
43930   {
43931     try {
43932       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
43933     } CALL_CATCH_EXCEPTION(0);
43934   }
43935
43936   jresult = (void *)result;
43937   return jresult;
43938 }
43939
43940
43941 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
43942   float jresult ;
43943   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
43944   float arg2 ;
43945   float arg3 ;
43946   float result;
43947
43948   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
43949   arg2 = (float)jarg2;
43950   arg3 = (float)jarg3;
43951   {
43952     try {
43953       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
43954     } CALL_CATCH_EXCEPTION(0);
43955   }
43956
43957   jresult = result;
43958   return jresult;
43959 }
43960
43961
43962 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
43963   float jresult ;
43964   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
43965   unsigned int arg2 ;
43966   unsigned int *arg3 = 0 ;
43967   bool arg4 ;
43968   float result;
43969
43970   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
43971   arg2 = (unsigned int)jarg2;
43972   arg3 = (unsigned int *)jarg3;
43973   arg4 = jarg4 ? true : false;
43974   {
43975     try {
43976       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
43977     } CALL_CATCH_EXCEPTION(0);
43978   }
43979
43980   jresult = result;
43981   return jresult;
43982 }
43983
43984
43985 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
43986   unsigned int jresult ;
43987   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
43988   float arg2 ;
43989   bool arg3 ;
43990   unsigned int result;
43991
43992   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
43993   arg2 = (float)jarg2;
43994   arg3 = jarg3 ? true : false;
43995   {
43996     try {
43997       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
43998     } CALL_CATCH_EXCEPTION(0);
43999   }
44000
44001   jresult = result;
44002   return jresult;
44003 }
44004
44005
44006 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
44007   unsigned int jresult ;
44008   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
44009   unsigned int result;
44010
44011   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
44012   {
44013     try {
44014       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
44015     } CALL_CATCH_EXCEPTION(0);
44016   }
44017
44018   jresult = result;
44019   return jresult;
44020 }
44021
44022
44023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
44024   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
44025
44026   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
44027   {
44028     try {
44029       delete arg1;
44030     } CALL_CATCH_EXCEPTION();
44031   }
44032
44033 }
44034
44035
44036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
44037   void * jresult ;
44038   float arg1 ;
44039   Dali::Toolkit::FixedRuler *result = 0 ;
44040
44041   arg1 = (float)jarg1;
44042   {
44043     try {
44044       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
44045     } CALL_CATCH_EXCEPTION(0);
44046   }
44047
44048   jresult = (void *)result;
44049   return jresult;
44050 }
44051
44052
44053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
44054   void * jresult ;
44055   Dali::Toolkit::FixedRuler *result = 0 ;
44056
44057   {
44058     try {
44059       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
44060     } CALL_CATCH_EXCEPTION(0);
44061   }
44062
44063   jresult = (void *)result;
44064   return jresult;
44065 }
44066
44067
44068 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
44069   float jresult ;
44070   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
44071   float arg2 ;
44072   float arg3 ;
44073   float result;
44074
44075   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
44076   arg2 = (float)jarg2;
44077   arg3 = (float)jarg3;
44078   {
44079     try {
44080       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
44081     } CALL_CATCH_EXCEPTION(0);
44082   }
44083
44084   jresult = result;
44085   return jresult;
44086 }
44087
44088
44089 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
44090   float jresult ;
44091   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
44092   unsigned int arg2 ;
44093   unsigned int *arg3 = 0 ;
44094   bool arg4 ;
44095   float result;
44096
44097   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
44098   arg2 = (unsigned int)jarg2;
44099   arg3 = (unsigned int *)jarg3;
44100   arg4 = jarg4 ? true : false;
44101   {
44102     try {
44103       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
44104     } CALL_CATCH_EXCEPTION(0);
44105   }
44106
44107   jresult = result;
44108   return jresult;
44109 }
44110
44111
44112 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
44113   unsigned int jresult ;
44114   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
44115   float arg2 ;
44116   bool arg3 ;
44117   unsigned int result;
44118
44119   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
44120   arg2 = (float)jarg2;
44121   arg3 = jarg3 ? true : false;
44122   {
44123     try {
44124       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
44125     } CALL_CATCH_EXCEPTION(0);
44126   }
44127
44128   jresult = result;
44129   return jresult;
44130 }
44131
44132
44133 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
44134   unsigned int jresult ;
44135   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
44136   unsigned int result;
44137
44138   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
44139   {
44140     try {
44141       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
44142     } CALL_CATCH_EXCEPTION(0);
44143   }
44144
44145   jresult = result;
44146   return jresult;
44147 }
44148
44149
44150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
44151   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
44152
44153   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
44154   {
44155     try {
44156       delete arg1;
44157     } CALL_CATCH_EXCEPTION();
44158   }
44159
44160 }
44161
44162
44163 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
44164   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
44165   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
44166
44167   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
44168   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
44169   if (arg1) (arg1)->scale = *arg2;
44170 }
44171
44172
44173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
44174   void * jresult ;
44175   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
44176   Dali::Toolkit::ClampState2D *result = 0 ;
44177
44178   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
44179   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
44180   jresult = (void *)result;
44181   return jresult;
44182 }
44183
44184
44185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
44186   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
44187   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
44188
44189   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
44190   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
44191   if (arg1) (arg1)->position = *arg2;
44192 }
44193
44194
44195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
44196   void * jresult ;
44197   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
44198   Dali::Toolkit::ClampState2D *result = 0 ;
44199
44200   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
44201   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
44202   jresult = (void *)result;
44203   return jresult;
44204 }
44205
44206
44207 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
44208   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
44209   Dali::Toolkit::ClampState arg2 ;
44210
44211   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
44212   arg2 = (Dali::Toolkit::ClampState)jarg2;
44213   if (arg1) (arg1)->rotation = arg2;
44214 }
44215
44216
44217 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
44218   int jresult ;
44219   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
44220   Dali::Toolkit::ClampState result;
44221
44222   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
44223   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
44224   jresult = (int)result;
44225   return jresult;
44226 }
44227
44228
44229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
44230   void * jresult ;
44231   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
44232
44233   {
44234     try {
44235       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
44236     } CALL_CATCH_EXCEPTION(0);
44237   }
44238
44239   jresult = (void *)result;
44240   return jresult;
44241 }
44242
44243
44244 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
44245   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
44246
44247   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
44248   {
44249     try {
44250       delete arg1;
44251     } CALL_CATCH_EXCEPTION();
44252   }
44253
44254 }
44255
44256
44257 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
44258   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
44259   Dali::Toolkit::SnapType arg2 ;
44260
44261   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
44262   arg2 = (Dali::Toolkit::SnapType)jarg2;
44263   if (arg1) (arg1)->type = arg2;
44264 }
44265
44266
44267 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
44268   int jresult ;
44269   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
44270   Dali::Toolkit::SnapType result;
44271
44272   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
44273   result = (Dali::Toolkit::SnapType) ((arg1)->type);
44274   jresult = (int)result;
44275   return jresult;
44276 }
44277
44278
44279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
44280   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
44281   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
44282
44283   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
44284   arg2 = (Dali::Vector2 *)jarg2;
44285   if (arg1) (arg1)->position = *arg2;
44286 }
44287
44288
44289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
44290   void * jresult ;
44291   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
44292   Dali::Vector2 *result = 0 ;
44293
44294   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
44295   result = (Dali::Vector2 *)& ((arg1)->position);
44296   jresult = (void *)result;
44297   return jresult;
44298 }
44299
44300
44301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
44302   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
44303   float arg2 ;
44304
44305   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
44306   arg2 = (float)jarg2;
44307   if (arg1) (arg1)->duration = arg2;
44308 }
44309
44310
44311 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
44312   float jresult ;
44313   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
44314   float result;
44315
44316   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
44317   result = (float) ((arg1)->duration);
44318   jresult = result;
44319   return jresult;
44320 }
44321
44322
44323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
44324   void * jresult ;
44325   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
44326
44327   {
44328     try {
44329       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
44330     } CALL_CATCH_EXCEPTION(0);
44331   }
44332
44333   jresult = (void *)result;
44334   return jresult;
44335 }
44336
44337
44338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
44339   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
44340
44341   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
44342   {
44343     try {
44344       delete arg1;
44345     } CALL_CATCH_EXCEPTION();
44346   }
44347
44348 }
44349
44350
44351 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
44352   int jresult ;
44353   int result;
44354
44355   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
44356   jresult = (int)result;
44357   return jresult;
44358 }
44359
44360
44361 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
44362   int jresult ;
44363   int result;
44364
44365   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
44366   jresult = (int)result;
44367   return jresult;
44368 }
44369
44370
44371 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
44372   int jresult ;
44373   int result;
44374
44375   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
44376   jresult = (int)result;
44377   return jresult;
44378 }
44379
44380
44381 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
44382   int jresult ;
44383   int result;
44384
44385   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
44386   jresult = (int)result;
44387   return jresult;
44388 }
44389
44390
44391 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_MODE_get() {
44392   int jresult ;
44393   int result;
44394
44395   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_MODE;
44396   jresult = (int)result;
44397   return jresult;
44398 }
44399
44400 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
44401   int jresult ;
44402   int result;
44403
44404   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
44405   jresult = (int)result;
44406   return jresult;
44407 }
44408
44409
44410 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
44411   int jresult ;
44412   int result;
44413
44414   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
44415   jresult = (int)result;
44416   return jresult;
44417 }
44418
44419
44420 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
44421   int jresult ;
44422   int result;
44423
44424   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
44425   jresult = (int)result;
44426   return jresult;
44427 }
44428
44429
44430 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
44431   int jresult ;
44432   int result;
44433
44434   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
44435   jresult = (int)result;
44436   return jresult;
44437 }
44438
44439
44440 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
44441   int jresult ;
44442   int result;
44443
44444   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
44445   jresult = (int)result;
44446   return jresult;
44447 }
44448
44449
44450 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
44451   int jresult ;
44452   int result;
44453
44454   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
44455   jresult = (int)result;
44456   return jresult;
44457 }
44458
44459
44460 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
44461   int jresult ;
44462   int result;
44463
44464   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
44465   jresult = (int)result;
44466   return jresult;
44467 }
44468
44469
44470 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
44471   int jresult ;
44472   int result;
44473
44474   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
44475   jresult = (int)result;
44476   return jresult;
44477 }
44478
44479
44480 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
44481   int jresult ;
44482   int result;
44483
44484   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
44485   jresult = (int)result;
44486   return jresult;
44487 }
44488
44489
44490 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
44491   int jresult ;
44492   int result;
44493
44494   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
44495   jresult = (int)result;
44496   return jresult;
44497 }
44498
44499
44500 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
44501   int jresult ;
44502   int result;
44503
44504   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
44505   jresult = (int)result;
44506   return jresult;
44507 }
44508
44509
44510 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
44511   int jresult ;
44512   int result;
44513
44514   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
44515   jresult = (int)result;
44516   return jresult;
44517 }
44518
44519
44520 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
44521   int jresult ;
44522   int result;
44523
44524   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
44525   jresult = (int)result;
44526   return jresult;
44527 }
44528
44529
44530 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
44531   int jresult ;
44532   int result;
44533
44534   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
44535   jresult = (int)result;
44536   return jresult;
44537 }
44538
44539
44540 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
44541   int jresult ;
44542   int result;
44543
44544   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
44545   jresult = (int)result;
44546   return jresult;
44547 }
44548
44549
44550 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
44551   int jresult ;
44552   int result;
44553
44554   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
44555   jresult = (int)result;
44556   return jresult;
44557 }
44558
44559
44560 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
44561   int jresult ;
44562   int result;
44563
44564   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
44565   jresult = (int)result;
44566   return jresult;
44567 }
44568
44569
44570 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
44571   int jresult ;
44572   int result;
44573
44574   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
44575   jresult = (int)result;
44576   return jresult;
44577 }
44578
44579
44580 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
44581   int jresult ;
44582   int result;
44583
44584   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
44585   jresult = (int)result;
44586   return jresult;
44587 }
44588
44589
44590 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
44591   int jresult ;
44592   int result;
44593
44594   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
44595   jresult = (int)result;
44596   return jresult;
44597 }
44598
44599
44600 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
44601   int jresult ;
44602   int result;
44603
44604   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
44605   jresult = (int)result;
44606   return jresult;
44607 }
44608
44609
44610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
44611   void * jresult ;
44612   Dali::Toolkit::ScrollView::Property *result = 0 ;
44613
44614   {
44615     try {
44616       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
44617     } CALL_CATCH_EXCEPTION(0);
44618   }
44619
44620   jresult = (void *)result;
44621   return jresult;
44622 }
44623
44624
44625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
44626   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
44627
44628   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
44629   {
44630     try {
44631       delete arg1;
44632     } CALL_CATCH_EXCEPTION();
44633   }
44634
44635 }
44636
44637
44638 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
44639   void * jresult ;
44640   Dali::Toolkit::ScrollView *result = 0 ;
44641
44642   {
44643     try {
44644       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
44645     } CALL_CATCH_EXCEPTION(0);
44646   }
44647
44648   jresult = (void *)result;
44649   return jresult;
44650 }
44651
44652
44653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
44654   void * jresult ;
44655   Dali::Toolkit::ScrollView *arg1 = 0 ;
44656   Dali::Toolkit::ScrollView *result = 0 ;
44657
44658   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44659   if (!arg1) {
44660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
44661     return 0;
44662   }
44663   {
44664     try {
44665       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
44666     } CALL_CATCH_EXCEPTION(0);
44667   }
44668
44669   jresult = (void *)result;
44670   return jresult;
44671 }
44672
44673
44674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
44675   void * jresult ;
44676   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44677   Dali::Toolkit::ScrollView *arg2 = 0 ;
44678   Dali::Toolkit::ScrollView *result = 0 ;
44679
44680   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44681   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
44682   if (!arg2) {
44683     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
44684     return 0;
44685   }
44686   {
44687     try {
44688       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
44689     } CALL_CATCH_EXCEPTION(0);
44690   }
44691
44692   jresult = (void *)result;
44693   return jresult;
44694 }
44695
44696
44697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
44698   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44699
44700   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44701   {
44702     try {
44703       delete arg1;
44704     } CALL_CATCH_EXCEPTION();
44705   }
44706
44707 }
44708
44709
44710 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
44711   void * jresult ;
44712   Dali::Toolkit::ScrollView result;
44713
44714   {
44715     try {
44716       result = Dali::Toolkit::ScrollView::New();
44717     } CALL_CATCH_EXCEPTION(0);
44718   }
44719
44720   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
44721   return jresult;
44722 }
44723
44724
44725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
44726   void * jresult ;
44727   Dali::BaseHandle arg1 ;
44728   Dali::BaseHandle *argp1 ;
44729   Dali::Toolkit::ScrollView result;
44730
44731   argp1 = (Dali::BaseHandle *)jarg1;
44732   if (!argp1) {
44733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44734     return 0;
44735   }
44736   arg1 = *argp1;
44737   {
44738     try {
44739       result = Dali::Toolkit::ScrollView::DownCast(arg1);
44740     } CALL_CATCH_EXCEPTION(0);
44741   }
44742
44743   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
44744   return jresult;
44745 }
44746
44747
44748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
44749   void * jresult ;
44750   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44751   Dali::AlphaFunction result;
44752
44753   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44754   {
44755     try {
44756       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
44757     } CALL_CATCH_EXCEPTION(0);
44758   }
44759
44760   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
44761   return jresult;
44762 }
44763
44764
44765 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
44766   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44767   Dali::AlphaFunction arg2 ;
44768   Dali::AlphaFunction *argp2 ;
44769
44770   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44771   argp2 = (Dali::AlphaFunction *)jarg2;
44772   if (!argp2) {
44773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
44774     return ;
44775   }
44776   arg2 = *argp2;
44777   {
44778     try {
44779       (arg1)->SetScrollSnapAlphaFunction(arg2);
44780     } CALL_CATCH_EXCEPTION();
44781   }
44782
44783 }
44784
44785
44786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
44787   void * jresult ;
44788   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44789   Dali::AlphaFunction result;
44790
44791   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44792   {
44793     try {
44794       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
44795     } CALL_CATCH_EXCEPTION(0);
44796   }
44797
44798   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
44799   return jresult;
44800 }
44801
44802
44803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
44804   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44805   Dali::AlphaFunction arg2 ;
44806   Dali::AlphaFunction *argp2 ;
44807
44808   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44809   argp2 = (Dali::AlphaFunction *)jarg2;
44810   if (!argp2) {
44811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
44812     return ;
44813   }
44814   arg2 = *argp2;
44815   {
44816     try {
44817       (arg1)->SetScrollFlickAlphaFunction(arg2);
44818     } CALL_CATCH_EXCEPTION();
44819   }
44820
44821 }
44822
44823
44824 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
44825   float jresult ;
44826   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44827   float result;
44828
44829   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44830   {
44831     try {
44832       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
44833     } CALL_CATCH_EXCEPTION(0);
44834   }
44835
44836   jresult = result;
44837   return jresult;
44838 }
44839
44840
44841 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
44842   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44843   float arg2 ;
44844
44845   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44846   arg2 = (float)jarg2;
44847   {
44848     try {
44849       (arg1)->SetScrollSnapDuration(arg2);
44850     } CALL_CATCH_EXCEPTION();
44851   }
44852
44853 }
44854
44855
44856 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
44857   float jresult ;
44858   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44859   float result;
44860
44861   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44862   {
44863     try {
44864       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
44865     } CALL_CATCH_EXCEPTION(0);
44866   }
44867
44868   jresult = result;
44869   return jresult;
44870 }
44871
44872
44873 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
44874   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44875   float arg2 ;
44876
44877   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44878   arg2 = (float)jarg2;
44879   {
44880     try {
44881       (arg1)->SetScrollFlickDuration(arg2);
44882     } CALL_CATCH_EXCEPTION();
44883   }
44884
44885 }
44886
44887
44888 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
44889   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44890   Dali::Toolkit::RulerPtr arg2 ;
44891   Dali::Toolkit::RulerPtr *argp2 ;
44892
44893   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44894   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
44895   if (!argp2) {
44896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
44897     return ;
44898   }
44899   arg2 = *argp2;
44900   {
44901     try {
44902       (arg1)->SetRulerX(arg2);
44903     } CALL_CATCH_EXCEPTION();
44904   }
44905
44906 }
44907
44908
44909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
44910   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44911   Dali::Toolkit::RulerPtr arg2 ;
44912   Dali::Toolkit::RulerPtr *argp2 ;
44913
44914   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44915   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
44916   if (!argp2) {
44917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
44918     return ;
44919   }
44920   arg2 = *argp2;
44921   {
44922     try {
44923       (arg1)->SetRulerY(arg2);
44924     } CALL_CATCH_EXCEPTION();
44925   }
44926
44927 }
44928
44929
44930 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
44931   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44932   bool arg2 ;
44933
44934   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44935   arg2 = jarg2 ? true : false;
44936   {
44937     try {
44938       (arg1)->SetScrollSensitive(arg2);
44939     } CALL_CATCH_EXCEPTION();
44940   }
44941
44942 }
44943
44944
44945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
44946   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44947   float arg2 ;
44948   float arg3 ;
44949
44950   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44951   arg2 = (float)jarg2;
44952   arg3 = (float)jarg3;
44953   {
44954     try {
44955       (arg1)->SetMaxOvershoot(arg2,arg3);
44956     } CALL_CATCH_EXCEPTION();
44957   }
44958
44959 }
44960
44961
44962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
44963   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44964   Dali::AlphaFunction arg2 ;
44965   Dali::AlphaFunction *argp2 ;
44966
44967   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44968   argp2 = (Dali::AlphaFunction *)jarg2;
44969   if (!argp2) {
44970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
44971     return ;
44972   }
44973   arg2 = *argp2;
44974   {
44975     try {
44976       (arg1)->SetSnapOvershootAlphaFunction(arg2);
44977     } CALL_CATCH_EXCEPTION();
44978   }
44979
44980 }
44981
44982
44983 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
44984   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44985   float arg2 ;
44986
44987   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44988   arg2 = (float)jarg2;
44989   {
44990     try {
44991       (arg1)->SetSnapOvershootDuration(arg2);
44992     } CALL_CATCH_EXCEPTION();
44993   }
44994
44995 }
44996
44997
44998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
44999   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45000   bool arg2 ;
45001
45002   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45003   arg2 = jarg2 ? true : false;
45004   {
45005     try {
45006       (arg1)->SetActorAutoSnap(arg2);
45007     } CALL_CATCH_EXCEPTION();
45008   }
45009
45010 }
45011
45012
45013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
45014   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45015   bool arg2 ;
45016
45017   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45018   arg2 = jarg2 ? true : false;
45019   {
45020     try {
45021       (arg1)->SetWrapMode(arg2);
45022     } CALL_CATCH_EXCEPTION();
45023   }
45024
45025 }
45026
45027
45028 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
45029   int jresult ;
45030   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45031   int result;
45032
45033   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45034   {
45035     try {
45036       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
45037     } CALL_CATCH_EXCEPTION(0);
45038   }
45039
45040   jresult = result;
45041   return jresult;
45042 }
45043
45044
45045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
45046   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45047   int arg2 ;
45048
45049   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45050   arg2 = (int)jarg2;
45051   {
45052     try {
45053       (arg1)->SetScrollUpdateDistance(arg2);
45054     } CALL_CATCH_EXCEPTION();
45055   }
45056
45057 }
45058
45059
45060 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
45061   unsigned int jresult ;
45062   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45063   bool result;
45064
45065   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45066   {
45067     try {
45068       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
45069     } CALL_CATCH_EXCEPTION(0);
45070   }
45071
45072   jresult = result;
45073   return jresult;
45074 }
45075
45076
45077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
45078   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45079   bool arg2 ;
45080
45081   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45082   arg2 = jarg2 ? true : false;
45083   {
45084     try {
45085       (arg1)->SetAxisAutoLock(arg2);
45086     } CALL_CATCH_EXCEPTION();
45087   }
45088
45089 }
45090
45091
45092 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
45093   float jresult ;
45094   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45095   float result;
45096
45097   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45098   {
45099     try {
45100       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
45101     } CALL_CATCH_EXCEPTION(0);
45102   }
45103
45104   jresult = result;
45105   return jresult;
45106 }
45107
45108
45109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
45110   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45111   float arg2 ;
45112
45113   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45114   arg2 = (float)jarg2;
45115   {
45116     try {
45117       (arg1)->SetAxisAutoLockGradient(arg2);
45118     } CALL_CATCH_EXCEPTION();
45119   }
45120
45121 }
45122
45123
45124 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
45125   float jresult ;
45126   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45127   float result;
45128
45129   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45130   {
45131     try {
45132       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
45133     } CALL_CATCH_EXCEPTION(0);
45134   }
45135
45136   jresult = result;
45137   return jresult;
45138 }
45139
45140
45141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
45142   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45143   float arg2 ;
45144
45145   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45146   arg2 = (float)jarg2;
45147   {
45148     try {
45149       (arg1)->SetFrictionCoefficient(arg2);
45150     } CALL_CATCH_EXCEPTION();
45151   }
45152
45153 }
45154
45155
45156 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
45157   float jresult ;
45158   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45159   float result;
45160
45161   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45162   {
45163     try {
45164       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
45165     } CALL_CATCH_EXCEPTION(0);
45166   }
45167
45168   jresult = result;
45169   return jresult;
45170 }
45171
45172
45173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
45174   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45175   float arg2 ;
45176
45177   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45178   arg2 = (float)jarg2;
45179   {
45180     try {
45181       (arg1)->SetFlickSpeedCoefficient(arg2);
45182     } CALL_CATCH_EXCEPTION();
45183   }
45184
45185 }
45186
45187
45188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
45189   void * jresult ;
45190   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45191   Dali::Vector2 result;
45192
45193   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45194   {
45195     try {
45196       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
45197     } CALL_CATCH_EXCEPTION(0);
45198   }
45199
45200   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
45201   return jresult;
45202 }
45203
45204
45205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
45206   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45207   Dali::Vector2 *arg2 = 0 ;
45208
45209   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45210   arg2 = (Dali::Vector2 *)jarg2;
45211   if (!arg2) {
45212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
45213     return ;
45214   }
45215   {
45216     try {
45217       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
45218     } CALL_CATCH_EXCEPTION();
45219   }
45220
45221 }
45222
45223
45224 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
45225   float jresult ;
45226   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45227   float result;
45228
45229   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45230   {
45231     try {
45232       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
45233     } CALL_CATCH_EXCEPTION(0);
45234   }
45235
45236   jresult = result;
45237   return jresult;
45238 }
45239
45240
45241 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
45242   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45243   float arg2 ;
45244
45245   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45246   arg2 = (float)jarg2;
45247   {
45248     try {
45249       (arg1)->SetMinimumSpeedForFlick(arg2);
45250     } CALL_CATCH_EXCEPTION();
45251   }
45252
45253 }
45254
45255
45256 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
45257   float jresult ;
45258   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45259   float result;
45260
45261   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45262   {
45263     try {
45264       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
45265     } CALL_CATCH_EXCEPTION(0);
45266   }
45267
45268   jresult = result;
45269   return jresult;
45270 }
45271
45272
45273 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
45274   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45275   float arg2 ;
45276
45277   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45278   arg2 = (float)jarg2;
45279   {
45280     try {
45281       (arg1)->SetMaxFlickSpeed(arg2);
45282     } CALL_CATCH_EXCEPTION();
45283   }
45284
45285 }
45286
45287
45288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
45289   void * jresult ;
45290   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45291   Dali::Vector2 result;
45292
45293   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45294   {
45295     try {
45296       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
45297     } CALL_CATCH_EXCEPTION(0);
45298   }
45299
45300   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
45301   return jresult;
45302 }
45303
45304
45305 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
45306   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45307   Dali::Vector2 arg2 ;
45308   Dali::Vector2 *argp2 ;
45309
45310   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45311   argp2 = (Dali::Vector2 *)jarg2;
45312   if (!argp2) {
45313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
45314     return ;
45315   }
45316   arg2 = *argp2;
45317   {
45318     try {
45319       (arg1)->SetWheelScrollDistanceStep(arg2);
45320     } CALL_CATCH_EXCEPTION();
45321   }
45322
45323 }
45324
45325
45326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
45327   void * jresult ;
45328   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45329   Dali::Vector2 result;
45330
45331   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45332   {
45333     try {
45334       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
45335     } CALL_CATCH_EXCEPTION(0);
45336   }
45337
45338   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
45339   return jresult;
45340 }
45341
45342
45343 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
45344   unsigned int jresult ;
45345   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45346   unsigned int result;
45347
45348   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45349   {
45350     try {
45351       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
45352     } CALL_CATCH_EXCEPTION(0);
45353   }
45354
45355   jresult = result;
45356   return jresult;
45357 }
45358
45359
45360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
45361   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45362   Dali::Vector2 *arg2 = 0 ;
45363
45364   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45365   arg2 = (Dali::Vector2 *)jarg2;
45366   if (!arg2) {
45367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
45368     return ;
45369   }
45370   {
45371     try {
45372       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
45373     } CALL_CATCH_EXCEPTION();
45374   }
45375
45376 }
45377
45378
45379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
45380   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45381   Dali::Vector2 *arg2 = 0 ;
45382   float arg3 ;
45383
45384   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45385   arg2 = (Dali::Vector2 *)jarg2;
45386   if (!arg2) {
45387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
45388     return ;
45389   }
45390   arg3 = (float)jarg3;
45391   {
45392     try {
45393       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
45394     } CALL_CATCH_EXCEPTION();
45395   }
45396
45397 }
45398
45399
45400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
45401   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45402   Dali::Vector2 *arg2 = 0 ;
45403   float arg3 ;
45404   Dali::AlphaFunction arg4 ;
45405   Dali::AlphaFunction *argp4 ;
45406
45407   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45408   arg2 = (Dali::Vector2 *)jarg2;
45409   if (!arg2) {
45410     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
45411     return ;
45412   }
45413   arg3 = (float)jarg3;
45414   argp4 = (Dali::AlphaFunction *)jarg4;
45415   if (!argp4) {
45416     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
45417     return ;
45418   }
45419   arg4 = *argp4;
45420   {
45421     try {
45422       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
45423     } CALL_CATCH_EXCEPTION();
45424   }
45425
45426 }
45427
45428
45429 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
45430   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45431   Dali::Vector2 *arg2 = 0 ;
45432   float arg3 ;
45433   Dali::Toolkit::DirectionBias arg4 ;
45434   Dali::Toolkit::DirectionBias arg5 ;
45435
45436   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45437   arg2 = (Dali::Vector2 *)jarg2;
45438   if (!arg2) {
45439     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
45440     return ;
45441   }
45442   arg3 = (float)jarg3;
45443   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
45444   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
45445   {
45446     try {
45447       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
45448     } CALL_CATCH_EXCEPTION();
45449   }
45450
45451 }
45452
45453
45454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
45455   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45456   Dali::Vector2 *arg2 = 0 ;
45457   float arg3 ;
45458   Dali::AlphaFunction arg4 ;
45459   Dali::Toolkit::DirectionBias arg5 ;
45460   Dali::Toolkit::DirectionBias arg6 ;
45461   Dali::AlphaFunction *argp4 ;
45462
45463   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45464   arg2 = (Dali::Vector2 *)jarg2;
45465   if (!arg2) {
45466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
45467     return ;
45468   }
45469   arg3 = (float)jarg3;
45470   argp4 = (Dali::AlphaFunction *)jarg4;
45471   if (!argp4) {
45472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
45473     return ;
45474   }
45475   arg4 = *argp4;
45476   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
45477   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
45478   {
45479     try {
45480       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
45481     } CALL_CATCH_EXCEPTION();
45482   }
45483
45484 }
45485
45486
45487 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
45488   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45489   unsigned int arg2 ;
45490
45491   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45492   arg2 = (unsigned int)jarg2;
45493   {
45494     try {
45495       (arg1)->ScrollTo(arg2);
45496     } CALL_CATCH_EXCEPTION();
45497   }
45498
45499 }
45500
45501
45502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
45503   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45504   unsigned int arg2 ;
45505   float arg3 ;
45506
45507   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45508   arg2 = (unsigned int)jarg2;
45509   arg3 = (float)jarg3;
45510   {
45511     try {
45512       (arg1)->ScrollTo(arg2,arg3);
45513     } CALL_CATCH_EXCEPTION();
45514   }
45515
45516 }
45517
45518
45519 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
45520   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45521   unsigned int arg2 ;
45522   float arg3 ;
45523   Dali::Toolkit::DirectionBias arg4 ;
45524
45525   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45526   arg2 = (unsigned int)jarg2;
45527   arg3 = (float)jarg3;
45528   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
45529   {
45530     try {
45531       (arg1)->ScrollTo(arg2,arg3,arg4);
45532     } CALL_CATCH_EXCEPTION();
45533   }
45534
45535 }
45536
45537
45538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
45539   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45540   Dali::Actor *arg2 = 0 ;
45541
45542   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45543   arg2 = (Dali::Actor *)jarg2;
45544   if (!arg2) {
45545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
45546     return ;
45547   }
45548   {
45549     try {
45550       (arg1)->ScrollTo(*arg2);
45551     } CALL_CATCH_EXCEPTION();
45552   }
45553
45554 }
45555
45556
45557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
45558   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45559   Dali::Actor *arg2 = 0 ;
45560   float arg3 ;
45561
45562   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45563   arg2 = (Dali::Actor *)jarg2;
45564   if (!arg2) {
45565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
45566     return ;
45567   }
45568   arg3 = (float)jarg3;
45569   {
45570     try {
45571       (arg1)->ScrollTo(*arg2,arg3);
45572     } CALL_CATCH_EXCEPTION();
45573   }
45574
45575 }
45576
45577
45578 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
45579   unsigned int jresult ;
45580   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45581   bool result;
45582
45583   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45584   {
45585     try {
45586       result = (bool)(arg1)->ScrollToSnapPoint();
45587     } CALL_CATCH_EXCEPTION(0);
45588   }
45589
45590   jresult = result;
45591   return jresult;
45592 }
45593
45594
45595 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
45596   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45597   Dali::Constraint arg2 ;
45598   Dali::Constraint *argp2 ;
45599
45600   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45601   argp2 = (Dali::Constraint *)jarg2;
45602   if (!argp2) {
45603     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
45604     return ;
45605   }
45606   arg2 = *argp2;
45607   {
45608     try {
45609       (arg1)->ApplyConstraintToChildren(arg2);
45610     } CALL_CATCH_EXCEPTION();
45611   }
45612
45613 }
45614
45615
45616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
45617   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45618
45619   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45620   {
45621     try {
45622       (arg1)->RemoveConstraintsFromChildren();
45623     } CALL_CATCH_EXCEPTION();
45624   }
45625
45626 }
45627
45628
45629 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
45630   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45631   Dali::Toolkit::ScrollViewEffect arg2 ;
45632   Dali::Toolkit::ScrollViewEffect *argp2 ;
45633
45634   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45635   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
45636   if (!argp2) {
45637     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
45638     return ;
45639   }
45640   arg2 = *argp2;
45641   {
45642     try {
45643       (arg1)->ApplyEffect(arg2);
45644     } CALL_CATCH_EXCEPTION();
45645   }
45646
45647 }
45648
45649
45650 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
45651   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45652   Dali::Toolkit::ScrollViewEffect arg2 ;
45653   Dali::Toolkit::ScrollViewEffect *argp2 ;
45654
45655   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45656   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
45657   if (!argp2) {
45658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
45659     return ;
45660   }
45661   arg2 = *argp2;
45662   {
45663     try {
45664       (arg1)->RemoveEffect(arg2);
45665     } CALL_CATCH_EXCEPTION();
45666   }
45667
45668 }
45669
45670
45671 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
45672   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45673
45674   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45675   {
45676     try {
45677       (arg1)->RemoveAllEffects();
45678     } CALL_CATCH_EXCEPTION();
45679   }
45680
45681 }
45682
45683
45684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
45685   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45686   Dali::Actor arg2 ;
45687   Dali::Actor *argp2 ;
45688
45689   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45690   argp2 = (Dali::Actor *)jarg2;
45691   if (!argp2) {
45692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
45693     return ;
45694   }
45695   arg2 = *argp2;
45696   {
45697     try {
45698       (arg1)->BindActor(arg2);
45699     } CALL_CATCH_EXCEPTION();
45700   }
45701
45702 }
45703
45704
45705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
45706   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45707   Dali::Actor arg2 ;
45708   Dali::Actor *argp2 ;
45709
45710   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45711   argp2 = (Dali::Actor *)jarg2;
45712   if (!argp2) {
45713     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
45714     return ;
45715   }
45716   arg2 = *argp2;
45717   {
45718     try {
45719       (arg1)->UnbindActor(arg2);
45720     } CALL_CATCH_EXCEPTION();
45721   }
45722
45723 }
45724
45725
45726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
45727   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45728   Dali::Radian arg2 ;
45729   Dali::Radian arg3 ;
45730   Dali::Radian *argp2 ;
45731   Dali::Radian *argp3 ;
45732
45733   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45734   argp2 = (Dali::Radian *)jarg2;
45735   if (!argp2) {
45736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
45737     return ;
45738   }
45739   arg2 = *argp2;
45740   argp3 = (Dali::Radian *)jarg3;
45741   if (!argp3) {
45742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
45743     return ;
45744   }
45745   arg3 = *argp3;
45746   {
45747     try {
45748       (arg1)->SetScrollingDirection(arg2,arg3);
45749     } CALL_CATCH_EXCEPTION();
45750   }
45751
45752 }
45753
45754
45755 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
45756   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45757   Dali::Radian arg2 ;
45758   Dali::Radian *argp2 ;
45759
45760   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45761   argp2 = (Dali::Radian *)jarg2;
45762   if (!argp2) {
45763     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
45764     return ;
45765   }
45766   arg2 = *argp2;
45767   {
45768     try {
45769       (arg1)->SetScrollingDirection(arg2);
45770     } CALL_CATCH_EXCEPTION();
45771   }
45772
45773 }
45774
45775
45776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
45777   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45778   Dali::Radian arg2 ;
45779   Dali::Radian *argp2 ;
45780
45781   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45782   argp2 = (Dali::Radian *)jarg2;
45783   if (!argp2) {
45784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
45785     return ;
45786   }
45787   arg2 = *argp2;
45788   {
45789     try {
45790       (arg1)->RemoveScrollingDirection(arg2);
45791     } CALL_CATCH_EXCEPTION();
45792   }
45793
45794 }
45795
45796
45797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
45798   void * jresult ;
45799   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45800   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
45801
45802   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45803   {
45804     try {
45805       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
45806     } CALL_CATCH_EXCEPTION(0);
45807   }
45808
45809   jresult = (void *)result;
45810   return jresult;
45811 }
45812
45813
45814 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
45815   int jresult ;
45816   int result;
45817
45818   result = (int)Dali::Toolkit::TableView::Property::ROWS;
45819   jresult = (int)result;
45820   return jresult;
45821 }
45822
45823
45824 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
45825   int jresult ;
45826   int result;
45827
45828   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
45829   jresult = (int)result;
45830   return jresult;
45831 }
45832
45833
45834 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
45835   int jresult ;
45836   int result;
45837
45838   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
45839   jresult = (int)result;
45840   return jresult;
45841 }
45842
45843
45844 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
45845   int jresult ;
45846   int result;
45847
45848   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
45849   jresult = (int)result;
45850   return jresult;
45851 }
45852
45853
45854 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
45855   int jresult ;
45856   int result;
45857
45858   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
45859   jresult = (int)result;
45860   return jresult;
45861 }
45862
45863
45864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
45865   void * jresult ;
45866   Dali::Toolkit::TableView::Property *result = 0 ;
45867
45868   {
45869     try {
45870       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
45871     } CALL_CATCH_EXCEPTION(0);
45872   }
45873
45874   jresult = (void *)result;
45875   return jresult;
45876 }
45877
45878
45879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
45880   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
45881
45882   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
45883   {
45884     try {
45885       delete arg1;
45886     } CALL_CATCH_EXCEPTION();
45887   }
45888
45889 }
45890
45891
45892 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
45893   int jresult ;
45894   int result;
45895
45896   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
45897   jresult = (int)result;
45898   return jresult;
45899 }
45900
45901
45902 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
45903   int jresult ;
45904   int result;
45905
45906   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
45907   jresult = (int)result;
45908   return jresult;
45909 }
45910
45911
45912 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
45913   int jresult ;
45914   int result;
45915
45916   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
45917   jresult = (int)result;
45918   return jresult;
45919 }
45920
45921
45922 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
45923   int jresult ;
45924   int result;
45925
45926   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
45927   jresult = (int)result;
45928   return jresult;
45929 }
45930
45931
45932 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
45933   int jresult ;
45934   int result;
45935
45936   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
45937   jresult = (int)result;
45938   return jresult;
45939 }
45940
45941
45942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
45943   void * jresult ;
45944   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
45945
45946   {
45947     try {
45948       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
45949     } CALL_CATCH_EXCEPTION(0);
45950   }
45951
45952   jresult = (void *)result;
45953   return jresult;
45954 }
45955
45956
45957 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
45958   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
45959
45960   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
45961   {
45962     try {
45963       delete arg1;
45964     } CALL_CATCH_EXCEPTION();
45965   }
45966
45967 }
45968
45969
45970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
45971   void * jresult ;
45972   unsigned int arg1 ;
45973   unsigned int arg2 ;
45974   unsigned int arg3 ;
45975   unsigned int arg4 ;
45976   Dali::Toolkit::TableView::CellPosition *result = 0 ;
45977
45978   arg1 = (unsigned int)jarg1;
45979   arg2 = (unsigned int)jarg2;
45980   arg3 = (unsigned int)jarg3;
45981   arg4 = (unsigned int)jarg4;
45982   {
45983     try {
45984       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
45985     } CALL_CATCH_EXCEPTION(0);
45986   }
45987
45988   jresult = (void *)result;
45989   return jresult;
45990 }
45991
45992
45993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
45994   void * jresult ;
45995   unsigned int arg1 ;
45996   unsigned int arg2 ;
45997   unsigned int arg3 ;
45998   Dali::Toolkit::TableView::CellPosition *result = 0 ;
45999
46000   arg1 = (unsigned int)jarg1;
46001   arg2 = (unsigned int)jarg2;
46002   arg3 = (unsigned int)jarg3;
46003   {
46004     try {
46005       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
46006     } CALL_CATCH_EXCEPTION(0);
46007   }
46008
46009   jresult = (void *)result;
46010   return jresult;
46011 }
46012
46013
46014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
46015   void * jresult ;
46016   unsigned int arg1 ;
46017   unsigned int arg2 ;
46018   Dali::Toolkit::TableView::CellPosition *result = 0 ;
46019
46020   arg1 = (unsigned int)jarg1;
46021   arg2 = (unsigned int)jarg2;
46022   {
46023     try {
46024       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
46025     } CALL_CATCH_EXCEPTION(0);
46026   }
46027
46028   jresult = (void *)result;
46029   return jresult;
46030 }
46031
46032
46033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
46034   void * jresult ;
46035   unsigned int arg1 ;
46036   Dali::Toolkit::TableView::CellPosition *result = 0 ;
46037
46038   arg1 = (unsigned int)jarg1;
46039   {
46040     try {
46041       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
46042     } CALL_CATCH_EXCEPTION(0);
46043   }
46044
46045   jresult = (void *)result;
46046   return jresult;
46047 }
46048
46049
46050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
46051   void * jresult ;
46052   Dali::Toolkit::TableView::CellPosition *result = 0 ;
46053
46054   {
46055     try {
46056       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
46057     } CALL_CATCH_EXCEPTION(0);
46058   }
46059
46060   jresult = (void *)result;
46061   return jresult;
46062 }
46063
46064
46065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
46066   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
46067   unsigned int arg2 ;
46068
46069   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
46070   arg2 = (unsigned int)jarg2;
46071   if (arg1) (arg1)->rowIndex = arg2;
46072 }
46073
46074
46075 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
46076   unsigned int jresult ;
46077   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
46078   unsigned int result;
46079
46080   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
46081   result = (unsigned int) ((arg1)->rowIndex);
46082   jresult = result;
46083   return jresult;
46084 }
46085
46086
46087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
46088   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
46089   unsigned int arg2 ;
46090
46091   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
46092   arg2 = (unsigned int)jarg2;
46093   if (arg1) (arg1)->columnIndex = arg2;
46094 }
46095
46096
46097 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
46098   unsigned int jresult ;
46099   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
46100   unsigned int result;
46101
46102   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
46103   result = (unsigned int) ((arg1)->columnIndex);
46104   jresult = result;
46105   return jresult;
46106 }
46107
46108
46109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
46110   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
46111   unsigned int arg2 ;
46112
46113   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
46114   arg2 = (unsigned int)jarg2;
46115   if (arg1) (arg1)->rowSpan = arg2;
46116 }
46117
46118
46119 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
46120   unsigned int jresult ;
46121   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
46122   unsigned int result;
46123
46124   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
46125   result = (unsigned int) ((arg1)->rowSpan);
46126   jresult = result;
46127   return jresult;
46128 }
46129
46130
46131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
46132   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
46133   unsigned int arg2 ;
46134
46135   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
46136   arg2 = (unsigned int)jarg2;
46137   if (arg1) (arg1)->columnSpan = arg2;
46138 }
46139
46140
46141 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
46142   unsigned int jresult ;
46143   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
46144   unsigned int result;
46145
46146   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
46147   result = (unsigned int) ((arg1)->columnSpan);
46148   jresult = result;
46149   return jresult;
46150 }
46151
46152
46153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
46154   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
46155
46156   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
46157   {
46158     try {
46159       delete arg1;
46160     } CALL_CATCH_EXCEPTION();
46161   }
46162
46163 }
46164
46165
46166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
46167   void * jresult ;
46168   Dali::Toolkit::TableView *result = 0 ;
46169
46170   {
46171     try {
46172       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
46173     } CALL_CATCH_EXCEPTION(0);
46174   }
46175
46176   jresult = (void *)result;
46177   return jresult;
46178 }
46179
46180
46181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
46182   void * jresult ;
46183   Dali::Toolkit::TableView *arg1 = 0 ;
46184   Dali::Toolkit::TableView *result = 0 ;
46185
46186   arg1 = (Dali::Toolkit::TableView *)jarg1;
46187   if (!arg1) {
46188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
46189     return 0;
46190   }
46191   {
46192     try {
46193       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
46194     } CALL_CATCH_EXCEPTION(0);
46195   }
46196
46197   jresult = (void *)result;
46198   return jresult;
46199 }
46200
46201
46202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
46203   void * jresult ;
46204   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46205   Dali::Toolkit::TableView *arg2 = 0 ;
46206   Dali::Toolkit::TableView *result = 0 ;
46207
46208   arg1 = (Dali::Toolkit::TableView *)jarg1;
46209   arg2 = (Dali::Toolkit::TableView *)jarg2;
46210   if (!arg2) {
46211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
46212     return 0;
46213   }
46214   {
46215     try {
46216       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
46217     } CALL_CATCH_EXCEPTION(0);
46218   }
46219
46220   jresult = (void *)result;
46221   return jresult;
46222 }
46223
46224
46225 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
46226   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46227
46228   arg1 = (Dali::Toolkit::TableView *)jarg1;
46229   {
46230     try {
46231       delete arg1;
46232     } CALL_CATCH_EXCEPTION();
46233   }
46234
46235 }
46236
46237
46238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
46239   void * jresult ;
46240   unsigned int arg1 ;
46241   unsigned int arg2 ;
46242   Dali::Toolkit::TableView result;
46243
46244   arg1 = (unsigned int)jarg1;
46245   arg2 = (unsigned int)jarg2;
46246   {
46247     try {
46248       result = Dali::Toolkit::TableView::New(arg1,arg2);
46249     } CALL_CATCH_EXCEPTION(0);
46250   }
46251
46252   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
46253   return jresult;
46254 }
46255
46256
46257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
46258   void * jresult ;
46259   Dali::BaseHandle arg1 ;
46260   Dali::BaseHandle *argp1 ;
46261   Dali::Toolkit::TableView result;
46262
46263   argp1 = (Dali::BaseHandle *)jarg1;
46264   if (!argp1) {
46265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
46266     return 0;
46267   }
46268   arg1 = *argp1;
46269   {
46270     try {
46271       result = Dali::Toolkit::TableView::DownCast(arg1);
46272     } CALL_CATCH_EXCEPTION(0);
46273   }
46274
46275   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
46276   return jresult;
46277 }
46278
46279
46280 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
46281   unsigned int jresult ;
46282   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46283   Dali::Actor arg2 ;
46284   Dali::Toolkit::TableView::CellPosition arg3 ;
46285   Dali::Actor *argp2 ;
46286   Dali::Toolkit::TableView::CellPosition *argp3 ;
46287   bool result;
46288
46289   arg1 = (Dali::Toolkit::TableView *)jarg1;
46290   argp2 = (Dali::Actor *)jarg2;
46291   if (!argp2) {
46292     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
46293     return 0;
46294   }
46295   arg2 = *argp2;
46296   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
46297   if (!argp3) {
46298     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
46299     return 0;
46300   }
46301   arg3 = *argp3;
46302   {
46303     try {
46304       result = (bool)(arg1)->AddChild(arg2,arg3);
46305     } CALL_CATCH_EXCEPTION(0);
46306   }
46307
46308   jresult = result;
46309   return jresult;
46310 }
46311
46312
46313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
46314   void * jresult ;
46315   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46316   Dali::Toolkit::TableView::CellPosition arg2 ;
46317   Dali::Toolkit::TableView::CellPosition *argp2 ;
46318   Dali::Actor result;
46319
46320   arg1 = (Dali::Toolkit::TableView *)jarg1;
46321   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
46322   if (!argp2) {
46323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
46324     return 0;
46325   }
46326   arg2 = *argp2;
46327   {
46328     try {
46329       result = (arg1)->GetChildAt(arg2);
46330     } CALL_CATCH_EXCEPTION(0);
46331   }
46332
46333   jresult = new Dali::Actor((const Dali::Actor &)result);
46334   return jresult;
46335 }
46336
46337
46338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
46339   void * jresult ;
46340   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46341   Dali::Toolkit::TableView::CellPosition arg2 ;
46342   Dali::Toolkit::TableView::CellPosition *argp2 ;
46343   Dali::Actor result;
46344
46345   arg1 = (Dali::Toolkit::TableView *)jarg1;
46346   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
46347   if (!argp2) {
46348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
46349     return 0;
46350   }
46351   arg2 = *argp2;
46352   {
46353     try {
46354       result = (arg1)->RemoveChildAt(arg2);
46355     } CALL_CATCH_EXCEPTION(0);
46356   }
46357
46358   jresult = new Dali::Actor((const Dali::Actor &)result);
46359   return jresult;
46360 }
46361
46362
46363 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
46364   unsigned int jresult ;
46365   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46366   Dali::Actor arg2 ;
46367   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
46368   Dali::Actor *argp2 ;
46369   bool result;
46370
46371   arg1 = (Dali::Toolkit::TableView *)jarg1;
46372   argp2 = (Dali::Actor *)jarg2;
46373   if (!argp2) {
46374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
46375     return 0;
46376   }
46377   arg2 = *argp2;
46378   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
46379   if (!arg3) {
46380     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
46381     return 0;
46382   }
46383   {
46384     try {
46385       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
46386     } CALL_CATCH_EXCEPTION(0);
46387   }
46388
46389   jresult = result;
46390   return jresult;
46391 }
46392
46393
46394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
46395   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46396   unsigned int arg2 ;
46397
46398   arg1 = (Dali::Toolkit::TableView *)jarg1;
46399   arg2 = (unsigned int)jarg2;
46400   {
46401     try {
46402       (arg1)->InsertRow(arg2);
46403     } CALL_CATCH_EXCEPTION();
46404   }
46405
46406 }
46407
46408
46409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
46410   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46411   unsigned int arg2 ;
46412
46413   arg1 = (Dali::Toolkit::TableView *)jarg1;
46414   arg2 = (unsigned int)jarg2;
46415   {
46416     try {
46417       (arg1)->DeleteRow(arg2);
46418     } CALL_CATCH_EXCEPTION();
46419   }
46420
46421 }
46422
46423
46424 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
46425   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46426   unsigned int arg2 ;
46427   std::vector< Dali::Actor > *arg3 = 0 ;
46428
46429   arg1 = (Dali::Toolkit::TableView *)jarg1;
46430   arg2 = (unsigned int)jarg2;
46431   arg3 = (std::vector< Dali::Actor > *)jarg3;
46432   if (!arg3) {
46433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
46434     return ;
46435   }
46436   {
46437     try {
46438       (arg1)->DeleteRow(arg2,*arg3);
46439     } CALL_CATCH_EXCEPTION();
46440   }
46441
46442 }
46443
46444
46445 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
46446   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46447   unsigned int arg2 ;
46448
46449   arg1 = (Dali::Toolkit::TableView *)jarg1;
46450   arg2 = (unsigned int)jarg2;
46451   {
46452     try {
46453       (arg1)->InsertColumn(arg2);
46454     } CALL_CATCH_EXCEPTION();
46455   }
46456
46457 }
46458
46459
46460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
46461   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46462   unsigned int arg2 ;
46463
46464   arg1 = (Dali::Toolkit::TableView *)jarg1;
46465   arg2 = (unsigned int)jarg2;
46466   {
46467     try {
46468       (arg1)->DeleteColumn(arg2);
46469     } CALL_CATCH_EXCEPTION();
46470   }
46471
46472 }
46473
46474
46475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
46476   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46477   unsigned int arg2 ;
46478   std::vector< Dali::Actor > *arg3 = 0 ;
46479
46480   arg1 = (Dali::Toolkit::TableView *)jarg1;
46481   arg2 = (unsigned int)jarg2;
46482   arg3 = (std::vector< Dali::Actor > *)jarg3;
46483   if (!arg3) {
46484     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
46485     return ;
46486   }
46487   {
46488     try {
46489       (arg1)->DeleteColumn(arg2,*arg3);
46490     } CALL_CATCH_EXCEPTION();
46491   }
46492
46493 }
46494
46495
46496 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
46497   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46498   unsigned int arg2 ;
46499   unsigned int arg3 ;
46500
46501   arg1 = (Dali::Toolkit::TableView *)jarg1;
46502   arg2 = (unsigned int)jarg2;
46503   arg3 = (unsigned int)jarg3;
46504   {
46505     try {
46506       (arg1)->Resize(arg2,arg3);
46507     } CALL_CATCH_EXCEPTION();
46508   }
46509
46510 }
46511
46512
46513 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
46514   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46515   unsigned int arg2 ;
46516   unsigned int arg3 ;
46517   std::vector< Dali::Actor > *arg4 = 0 ;
46518
46519   arg1 = (Dali::Toolkit::TableView *)jarg1;
46520   arg2 = (unsigned int)jarg2;
46521   arg3 = (unsigned int)jarg3;
46522   arg4 = (std::vector< Dali::Actor > *)jarg4;
46523   if (!arg4) {
46524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
46525     return ;
46526   }
46527   {
46528     try {
46529       (arg1)->Resize(arg2,arg3,*arg4);
46530     } CALL_CATCH_EXCEPTION();
46531   }
46532
46533 }
46534
46535
46536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
46537   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46538   Dali::Size arg2 ;
46539   Dali::Size *argp2 ;
46540
46541   arg1 = (Dali::Toolkit::TableView *)jarg1;
46542   argp2 = (Dali::Size *)jarg2;
46543   if (!argp2) {
46544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
46545     return ;
46546   }
46547   arg2 = *argp2;
46548   {
46549     try {
46550       (arg1)->SetCellPadding(arg2);
46551     } CALL_CATCH_EXCEPTION();
46552   }
46553
46554 }
46555
46556
46557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
46558   void * jresult ;
46559   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46560   Dali::Size result;
46561
46562   arg1 = (Dali::Toolkit::TableView *)jarg1;
46563   {
46564     try {
46565       result = (arg1)->GetCellPadding();
46566     } CALL_CATCH_EXCEPTION(0);
46567   }
46568
46569   jresult = new Dali::Size((const Dali::Size &)result);
46570   return jresult;
46571 }
46572
46573
46574 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
46575   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46576   unsigned int arg2 ;
46577
46578   arg1 = (Dali::Toolkit::TableView *)jarg1;
46579   arg2 = (unsigned int)jarg2;
46580   {
46581     try {
46582       (arg1)->SetFitHeight(arg2);
46583     } CALL_CATCH_EXCEPTION();
46584   }
46585
46586 }
46587
46588
46589 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
46590   unsigned int jresult ;
46591   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46592   unsigned int arg2 ;
46593   bool result;
46594
46595   arg1 = (Dali::Toolkit::TableView *)jarg1;
46596   arg2 = (unsigned int)jarg2;
46597   {
46598     try {
46599       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
46600     } CALL_CATCH_EXCEPTION(0);
46601   }
46602
46603   jresult = result;
46604   return jresult;
46605 }
46606
46607
46608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
46609   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46610   unsigned int arg2 ;
46611
46612   arg1 = (Dali::Toolkit::TableView *)jarg1;
46613   arg2 = (unsigned int)jarg2;
46614   {
46615     try {
46616       (arg1)->SetFitWidth(arg2);
46617     } CALL_CATCH_EXCEPTION();
46618   }
46619
46620 }
46621
46622
46623 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
46624   unsigned int jresult ;
46625   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46626   unsigned int arg2 ;
46627   bool result;
46628
46629   arg1 = (Dali::Toolkit::TableView *)jarg1;
46630   arg2 = (unsigned int)jarg2;
46631   {
46632     try {
46633       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
46634     } CALL_CATCH_EXCEPTION(0);
46635   }
46636
46637   jresult = result;
46638   return jresult;
46639 }
46640
46641
46642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
46643   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46644   unsigned int arg2 ;
46645   float arg3 ;
46646
46647   arg1 = (Dali::Toolkit::TableView *)jarg1;
46648   arg2 = (unsigned int)jarg2;
46649   arg3 = (float)jarg3;
46650   {
46651     try {
46652       (arg1)->SetFixedHeight(arg2,arg3);
46653     } CALL_CATCH_EXCEPTION();
46654   }
46655
46656 }
46657
46658
46659 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
46660   float jresult ;
46661   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46662   unsigned int arg2 ;
46663   float result;
46664
46665   arg1 = (Dali::Toolkit::TableView *)jarg1;
46666   arg2 = (unsigned int)jarg2;
46667   {
46668     try {
46669       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
46670     } CALL_CATCH_EXCEPTION(0);
46671   }
46672
46673   jresult = result;
46674   return jresult;
46675 }
46676
46677
46678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
46679   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46680   unsigned int arg2 ;
46681   float arg3 ;
46682
46683   arg1 = (Dali::Toolkit::TableView *)jarg1;
46684   arg2 = (unsigned int)jarg2;
46685   arg3 = (float)jarg3;
46686   {
46687     try {
46688       (arg1)->SetRelativeHeight(arg2,arg3);
46689     } CALL_CATCH_EXCEPTION();
46690   }
46691
46692 }
46693
46694
46695 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
46696   float jresult ;
46697   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46698   unsigned int arg2 ;
46699   float result;
46700
46701   arg1 = (Dali::Toolkit::TableView *)jarg1;
46702   arg2 = (unsigned int)jarg2;
46703   {
46704     try {
46705       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
46706     } CALL_CATCH_EXCEPTION(0);
46707   }
46708
46709   jresult = result;
46710   return jresult;
46711 }
46712
46713
46714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
46715   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46716   unsigned int arg2 ;
46717   float arg3 ;
46718
46719   arg1 = (Dali::Toolkit::TableView *)jarg1;
46720   arg2 = (unsigned int)jarg2;
46721   arg3 = (float)jarg3;
46722   {
46723     try {
46724       (arg1)->SetFixedWidth(arg2,arg3);
46725     } CALL_CATCH_EXCEPTION();
46726   }
46727
46728 }
46729
46730
46731 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
46732   float jresult ;
46733   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46734   unsigned int arg2 ;
46735   float result;
46736
46737   arg1 = (Dali::Toolkit::TableView *)jarg1;
46738   arg2 = (unsigned int)jarg2;
46739   {
46740     try {
46741       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
46742     } CALL_CATCH_EXCEPTION(0);
46743   }
46744
46745   jresult = result;
46746   return jresult;
46747 }
46748
46749
46750 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
46751   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46752   unsigned int arg2 ;
46753   float arg3 ;
46754
46755   arg1 = (Dali::Toolkit::TableView *)jarg1;
46756   arg2 = (unsigned int)jarg2;
46757   arg3 = (float)jarg3;
46758   {
46759     try {
46760       (arg1)->SetRelativeWidth(arg2,arg3);
46761     } CALL_CATCH_EXCEPTION();
46762   }
46763
46764 }
46765
46766
46767 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
46768   float jresult ;
46769   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46770   unsigned int arg2 ;
46771   float result;
46772
46773   arg1 = (Dali::Toolkit::TableView *)jarg1;
46774   arg2 = (unsigned int)jarg2;
46775   {
46776     try {
46777       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
46778     } CALL_CATCH_EXCEPTION(0);
46779   }
46780
46781   jresult = result;
46782   return jresult;
46783 }
46784
46785
46786 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
46787   unsigned int jresult ;
46788   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46789   unsigned int result;
46790
46791   arg1 = (Dali::Toolkit::TableView *)jarg1;
46792   {
46793     try {
46794       result = (unsigned int)(arg1)->GetRows();
46795     } CALL_CATCH_EXCEPTION(0);
46796   }
46797
46798   jresult = result;
46799   return jresult;
46800 }
46801
46802
46803 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
46804   unsigned int jresult ;
46805   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46806   unsigned int result;
46807
46808   arg1 = (Dali::Toolkit::TableView *)jarg1;
46809   {
46810     try {
46811       result = (unsigned int)(arg1)->GetColumns();
46812     } CALL_CATCH_EXCEPTION(0);
46813   }
46814
46815   jresult = result;
46816   return jresult;
46817 }
46818
46819
46820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
46821   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46822   Dali::Toolkit::TableView::CellPosition arg2 ;
46823   Dali::HorizontalAlignment::Type arg3 ;
46824   Dali::VerticalAlignment::Type arg4 ;
46825   Dali::Toolkit::TableView::CellPosition *argp2 ;
46826
46827   arg1 = (Dali::Toolkit::TableView *)jarg1;
46828   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
46829   if (!argp2) {
46830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
46831     return ;
46832   }
46833   arg2 = *argp2;
46834   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
46835   arg4 = (Dali::VerticalAlignment::Type)jarg4;
46836   {
46837     try {
46838       (arg1)->SetCellAlignment(arg2,arg3,arg4);
46839     } CALL_CATCH_EXCEPTION();
46840   }
46841
46842 }
46843
46844
46845 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
46846   unsigned int jresult ;
46847   unsigned int result;
46848
46849   result = (unsigned int)(unsigned int)Dali::Toolkit::DevelText::DEFAULT_RENDERING_BACKEND;
46850   jresult = result;
46851   return jresult;
46852 }
46853
46854
46855 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
46856   int jresult ;
46857   int result;
46858
46859   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
46860   jresult = (int)result;
46861   return jresult;
46862 }
46863
46864
46865 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
46866   int jresult ;
46867   int result;
46868
46869   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
46870   jresult = (int)result;
46871   return jresult;
46872 }
46873
46874
46875 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
46876   int jresult ;
46877   int result;
46878
46879   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
46880   jresult = (int)result;
46881   return jresult;
46882 }
46883
46884
46885 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
46886   int jresult ;
46887   int result;
46888
46889   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
46890   jresult = (int)result;
46891   return jresult;
46892 }
46893
46894
46895 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
46896   int jresult ;
46897   int result;
46898
46899   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
46900   jresult = (int)result;
46901   return jresult;
46902 }
46903
46904
46905 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
46906   int jresult ;
46907   int result;
46908
46909   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
46910   jresult = (int)result;
46911   return jresult;
46912 }
46913
46914
46915 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
46916   int jresult ;
46917   int result;
46918
46919   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
46920   jresult = (int)result;
46921   return jresult;
46922 }
46923
46924
46925 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
46926   int jresult ;
46927   int result;
46928
46929   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
46930   jresult = (int)result;
46931   return jresult;
46932 }
46933
46934
46935 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
46936   int jresult ;
46937   int result;
46938
46939   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
46940   jresult = (int)result;
46941   return jresult;
46942 }
46943
46944
46945 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
46946   int jresult ;
46947   int result;
46948
46949   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
46950   jresult = (int)result;
46951   return jresult;
46952 }
46953
46954
46955 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
46956   int jresult ;
46957   int result;
46958
46959   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
46960   jresult = (int)result;
46961   return jresult;
46962 }
46963
46964
46965 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
46966   int jresult ;
46967   int result;
46968
46969   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
46970   jresult = (int)result;
46971   return jresult;
46972 }
46973
46974
46975 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
46976   int jresult ;
46977   int result;
46978
46979   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
46980   jresult = (int)result;
46981   return jresult;
46982 }
46983
46984
46985 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
46986   int jresult ;
46987   int result;
46988
46989   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
46990   jresult = (int)result;
46991   return jresult;
46992 }
46993
46994
46995 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
46996   int jresult ;
46997   int result;
46998
46999   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
47000   jresult = (int)result;
47001   return jresult;
47002 }
47003
47004
47005 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
47006   int jresult ;
47007   int result;
47008
47009   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
47010   jresult = (int)result;
47011   return jresult;
47012 }
47013
47014
47015 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
47016   int jresult ;
47017   int result;
47018
47019   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
47020   jresult = (int)result;
47021   return jresult;
47022 }
47023
47024
47025 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
47026   int jresult ;
47027   int result;
47028
47029   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
47030   jresult = (int)result;
47031   return jresult;
47032 }
47033
47034
47035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
47036   void * jresult ;
47037   Dali::Toolkit::TextLabel::Property *result = 0 ;
47038
47039   {
47040     try {
47041       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
47042     } CALL_CATCH_EXCEPTION(0);
47043   }
47044
47045   jresult = (void *)result;
47046   return jresult;
47047 }
47048
47049
47050 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
47051   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
47052
47053   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
47054   {
47055     try {
47056       delete arg1;
47057     } CALL_CATCH_EXCEPTION();
47058   }
47059
47060 }
47061
47062
47063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
47064   void * jresult ;
47065   Dali::Toolkit::TextLabel result;
47066
47067   {
47068     try {
47069       result = Dali::Toolkit::TextLabel::New();
47070     } CALL_CATCH_EXCEPTION(0);
47071   }
47072
47073   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
47074   return jresult;
47075 }
47076
47077
47078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
47079   void * jresult ;
47080   std::string *arg1 = 0 ;
47081   Dali::Toolkit::TextLabel result;
47082
47083   if (!jarg1) {
47084     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
47085     return 0;
47086   }
47087   std::string arg1_str(jarg1);
47088   arg1 = &arg1_str;
47089   {
47090     try {
47091       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
47092     } CALL_CATCH_EXCEPTION(0);
47093   }
47094
47095   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
47096
47097   //argout typemap for const std::string&
47098
47099   return jresult;
47100 }
47101
47102
47103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
47104   void * jresult ;
47105   Dali::Toolkit::TextLabel *result = 0 ;
47106
47107   {
47108     try {
47109       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
47110     } CALL_CATCH_EXCEPTION(0);
47111   }
47112
47113   jresult = (void *)result;
47114   return jresult;
47115 }
47116
47117
47118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
47119   void * jresult ;
47120   Dali::Toolkit::TextLabel *arg1 = 0 ;
47121   Dali::Toolkit::TextLabel *result = 0 ;
47122
47123   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
47124   if (!arg1) {
47125     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
47126     return 0;
47127   }
47128   {
47129     try {
47130       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
47131     } CALL_CATCH_EXCEPTION(0);
47132   }
47133
47134   jresult = (void *)result;
47135   return jresult;
47136 }
47137
47138
47139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
47140   void * jresult ;
47141   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
47142   Dali::Toolkit::TextLabel *arg2 = 0 ;
47143   Dali::Toolkit::TextLabel *result = 0 ;
47144
47145   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
47146   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
47147   if (!arg2) {
47148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
47149     return 0;
47150   }
47151   {
47152     try {
47153       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
47154     } CALL_CATCH_EXCEPTION(0);
47155   }
47156
47157   jresult = (void *)result;
47158   return jresult;
47159 }
47160
47161
47162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
47163   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
47164
47165   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
47166   {
47167     try {
47168       delete arg1;
47169     } CALL_CATCH_EXCEPTION();
47170   }
47171
47172 }
47173
47174
47175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
47176   void * jresult ;
47177   Dali::BaseHandle arg1 ;
47178   Dali::BaseHandle *argp1 ;
47179   Dali::Toolkit::TextLabel result;
47180
47181   argp1 = (Dali::BaseHandle *)jarg1;
47182   if (!argp1) {
47183     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
47184     return 0;
47185   }
47186   arg1 = *argp1;
47187   {
47188     try {
47189       result = Dali::Toolkit::TextLabel::DownCast(arg1);
47190     } CALL_CATCH_EXCEPTION(0);
47191   }
47192
47193   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
47194   return jresult;
47195 }
47196
47197
47198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
47199   void * jresult ;
47200   Dali::Toolkit::AccessibilityManager *result = 0 ;
47201
47202   {
47203     try {
47204       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
47205     } CALL_CATCH_EXCEPTION(0);
47206   }
47207
47208   jresult = (void *)result;
47209   return jresult;
47210 }
47211
47212
47213 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
47214   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47215
47216   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47217   {
47218     try {
47219       delete arg1;
47220     } CALL_CATCH_EXCEPTION();
47221   }
47222
47223 }
47224
47225
47226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
47227   void * jresult ;
47228   Dali::Toolkit::AccessibilityManager result;
47229
47230   {
47231     try {
47232       result = Dali::Toolkit::AccessibilityManager::Get();
47233     } CALL_CATCH_EXCEPTION(0);
47234   }
47235
47236   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
47237   return jresult;
47238 }
47239
47240
47241 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
47242   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47243   Dali::Actor arg2 ;
47244   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
47245   std::string *arg4 = 0 ;
47246   Dali::Actor *argp2 ;
47247
47248   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47249   argp2 = (Dali::Actor *)jarg2;
47250   if (!argp2) {
47251     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
47252     return ;
47253   }
47254   arg2 = *argp2;
47255   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
47256   if (!jarg4) {
47257     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
47258     return ;
47259   }
47260   std::string arg4_str(jarg4);
47261   arg4 = &arg4_str;
47262   {
47263     try {
47264       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
47265     } CALL_CATCH_EXCEPTION();
47266   }
47267
47268
47269   //argout typemap for const std::string&
47270
47271 }
47272
47273
47274 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
47275   char * jresult ;
47276   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47277   Dali::Actor arg2 ;
47278   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
47279   Dali::Actor *argp2 ;
47280   std::string result;
47281
47282   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47283   argp2 = (Dali::Actor *)jarg2;
47284   if (!argp2) {
47285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
47286     return 0;
47287   }
47288   arg2 = *argp2;
47289   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
47290   {
47291     try {
47292       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
47293     } CALL_CATCH_EXCEPTION(0);
47294   }
47295
47296   jresult = SWIG_csharp_string_callback((&result)->c_str());
47297   return jresult;
47298 }
47299
47300
47301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
47302   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47303   Dali::Actor arg2 ;
47304   unsigned int arg3 ;
47305   Dali::Actor *argp2 ;
47306
47307   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47308   argp2 = (Dali::Actor *)jarg2;
47309   if (!argp2) {
47310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
47311     return ;
47312   }
47313   arg2 = *argp2;
47314   arg3 = (unsigned int)jarg3;
47315   {
47316     try {
47317       (arg1)->SetFocusOrder(arg2,arg3);
47318     } CALL_CATCH_EXCEPTION();
47319   }
47320
47321 }
47322
47323
47324 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
47325   unsigned int jresult ;
47326   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47327   Dali::Actor arg2 ;
47328   Dali::Actor *argp2 ;
47329   unsigned int result;
47330
47331   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47332   argp2 = (Dali::Actor *)jarg2;
47333   if (!argp2) {
47334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
47335     return 0;
47336   }
47337   arg2 = *argp2;
47338   {
47339     try {
47340       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
47341     } CALL_CATCH_EXCEPTION(0);
47342   }
47343
47344   jresult = result;
47345   return jresult;
47346 }
47347
47348
47349 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
47350   unsigned int jresult ;
47351   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47352   unsigned int result;
47353
47354   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47355   {
47356     try {
47357       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
47358     } CALL_CATCH_EXCEPTION(0);
47359   }
47360
47361   jresult = result;
47362   return jresult;
47363 }
47364
47365
47366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
47367   void * jresult ;
47368   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47369   unsigned int arg2 ;
47370   Dali::Actor result;
47371
47372   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47373   arg2 = (unsigned int)jarg2;
47374   {
47375     try {
47376       result = (arg1)->GetActorByFocusOrder(arg2);
47377     } CALL_CATCH_EXCEPTION(0);
47378   }
47379
47380   jresult = new Dali::Actor((const Dali::Actor &)result);
47381   return jresult;
47382 }
47383
47384
47385 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
47386   unsigned int jresult ;
47387   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47388   Dali::Actor arg2 ;
47389   Dali::Actor *argp2 ;
47390   bool result;
47391
47392   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47393   argp2 = (Dali::Actor *)jarg2;
47394   if (!argp2) {
47395     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
47396     return 0;
47397   }
47398   arg2 = *argp2;
47399   {
47400     try {
47401       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
47402     } CALL_CATCH_EXCEPTION(0);
47403   }
47404
47405   jresult = result;
47406   return jresult;
47407 }
47408
47409
47410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
47411   void * jresult ;
47412   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47413   Dali::Actor result;
47414
47415   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47416   {
47417     try {
47418       result = (arg1)->GetCurrentFocusActor();
47419     } CALL_CATCH_EXCEPTION(0);
47420   }
47421
47422   jresult = new Dali::Actor((const Dali::Actor &)result);
47423   return jresult;
47424 }
47425
47426
47427 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
47428   void * jresult ;
47429   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47430   Dali::Actor result;
47431
47432   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47433   {
47434     try {
47435       result = (arg1)->GetCurrentFocusGroup();
47436     } CALL_CATCH_EXCEPTION(0);
47437   }
47438
47439   jresult = new Dali::Actor((const Dali::Actor &)result);
47440   return jresult;
47441 }
47442
47443
47444 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
47445   unsigned int jresult ;
47446   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47447   unsigned int result;
47448
47449   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47450   {
47451     try {
47452       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
47453     } CALL_CATCH_EXCEPTION(0);
47454   }
47455
47456   jresult = result;
47457   return jresult;
47458 }
47459
47460
47461 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
47462   unsigned int jresult ;
47463   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47464   bool result;
47465
47466   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47467   {
47468     try {
47469       result = (bool)(arg1)->MoveFocusForward();
47470     } CALL_CATCH_EXCEPTION(0);
47471   }
47472
47473   jresult = result;
47474   return jresult;
47475 }
47476
47477
47478 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
47479   unsigned int jresult ;
47480   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47481   bool result;
47482
47483   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47484   {
47485     try {
47486       result = (bool)(arg1)->MoveFocusBackward();
47487     } CALL_CATCH_EXCEPTION(0);
47488   }
47489
47490   jresult = result;
47491   return jresult;
47492 }
47493
47494
47495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
47496   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47497
47498   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47499   {
47500     try {
47501       (arg1)->ClearFocus();
47502     } CALL_CATCH_EXCEPTION();
47503   }
47504
47505 }
47506
47507
47508 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
47509   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47510
47511   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47512   {
47513     try {
47514       (arg1)->Reset();
47515     } CALL_CATCH_EXCEPTION();
47516   }
47517
47518 }
47519
47520
47521 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
47522   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47523   Dali::Actor arg2 ;
47524   bool arg3 ;
47525   Dali::Actor *argp2 ;
47526
47527   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47528   argp2 = (Dali::Actor *)jarg2;
47529   if (!argp2) {
47530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
47531     return ;
47532   }
47533   arg2 = *argp2;
47534   arg3 = jarg3 ? true : false;
47535   {
47536     try {
47537       (arg1)->SetFocusGroup(arg2,arg3);
47538     } CALL_CATCH_EXCEPTION();
47539   }
47540
47541 }
47542
47543
47544 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
47545   unsigned int jresult ;
47546   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47547   Dali::Actor arg2 ;
47548   Dali::Actor *argp2 ;
47549   bool result;
47550
47551   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47552   argp2 = (Dali::Actor *)jarg2;
47553   if (!argp2) {
47554     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
47555     return 0;
47556   }
47557   arg2 = *argp2;
47558   {
47559     try {
47560       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
47561     } CALL_CATCH_EXCEPTION(0);
47562   }
47563
47564   jresult = result;
47565   return jresult;
47566 }
47567
47568
47569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
47570   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47571   bool arg2 ;
47572
47573   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47574   arg2 = jarg2 ? true : false;
47575   {
47576     try {
47577       (arg1)->SetGroupMode(arg2);
47578     } CALL_CATCH_EXCEPTION();
47579   }
47580
47581 }
47582
47583
47584 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
47585   unsigned int jresult ;
47586   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47587   bool result;
47588
47589   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47590   {
47591     try {
47592       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
47593     } CALL_CATCH_EXCEPTION(0);
47594   }
47595
47596   jresult = result;
47597   return jresult;
47598 }
47599
47600
47601 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
47602   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47603   bool arg2 ;
47604
47605   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47606   arg2 = jarg2 ? true : false;
47607   {
47608     try {
47609       (arg1)->SetWrapMode(arg2);
47610     } CALL_CATCH_EXCEPTION();
47611   }
47612
47613 }
47614
47615
47616 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
47617   unsigned int jresult ;
47618   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47619   bool result;
47620
47621   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47622   {
47623     try {
47624       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
47625     } CALL_CATCH_EXCEPTION(0);
47626   }
47627
47628   jresult = result;
47629   return jresult;
47630 }
47631
47632
47633 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
47634   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47635   Dali::Actor arg2 ;
47636   Dali::Actor *argp2 ;
47637
47638   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47639   argp2 = (Dali::Actor *)jarg2;
47640   if (!argp2) {
47641     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
47642     return ;
47643   }
47644   arg2 = *argp2;
47645   {
47646     try {
47647       (arg1)->SetFocusIndicatorActor(arg2);
47648     } CALL_CATCH_EXCEPTION();
47649   }
47650
47651 }
47652
47653
47654 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
47655   void * jresult ;
47656   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47657   Dali::Actor result;
47658
47659   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47660   {
47661     try {
47662       result = (arg1)->GetFocusIndicatorActor();
47663     } CALL_CATCH_EXCEPTION(0);
47664   }
47665
47666   jresult = new Dali::Actor((const Dali::Actor &)result);
47667   return jresult;
47668 }
47669
47670
47671 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
47672   void * jresult ;
47673   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47674   Dali::Actor arg2 ;
47675   Dali::Actor *argp2 ;
47676   Dali::Actor result;
47677
47678   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47679   argp2 = (Dali::Actor *)jarg2;
47680   if (!argp2) {
47681     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
47682     return 0;
47683   }
47684   arg2 = *argp2;
47685   {
47686     try {
47687       result = (arg1)->GetFocusGroup(arg2);
47688     } CALL_CATCH_EXCEPTION(0);
47689   }
47690
47691   jresult = new Dali::Actor((const Dali::Actor &)result);
47692   return jresult;
47693 }
47694
47695
47696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
47697   void * jresult ;
47698   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47699   Dali::Vector2 result;
47700
47701   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47702   {
47703     try {
47704       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
47705     } CALL_CATCH_EXCEPTION(0);
47706   }
47707
47708   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
47709   return jresult;
47710 }
47711
47712
47713 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
47714   void * jresult ;
47715   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47716   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
47717
47718   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47719   {
47720     try {
47721       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
47722     } CALL_CATCH_EXCEPTION(0);
47723   }
47724
47725   jresult = (void *)result;
47726   return jresult;
47727 }
47728
47729
47730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
47731   void * jresult ;
47732   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47733   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
47734
47735   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47736   {
47737     try {
47738       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
47739     } CALL_CATCH_EXCEPTION(0);
47740   }
47741
47742   jresult = (void *)result;
47743   return jresult;
47744 }
47745
47746
47747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
47748   void * jresult ;
47749   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47750   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
47751
47752   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47753   {
47754     try {
47755       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
47756     } CALL_CATCH_EXCEPTION(0);
47757   }
47758
47759   jresult = (void *)result;
47760   return jresult;
47761 }
47762
47763
47764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
47765   void * jresult ;
47766   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47767   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
47768
47769   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47770   {
47771     try {
47772       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
47773     } CALL_CATCH_EXCEPTION(0);
47774   }
47775
47776   jresult = (void *)result;
47777   return jresult;
47778 }
47779
47780
47781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
47782   void * jresult ;
47783   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47784   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
47785
47786   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47787   {
47788     try {
47789       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
47790     } CALL_CATCH_EXCEPTION(0);
47791   }
47792
47793   jresult = (void *)result;
47794   return jresult;
47795 }
47796
47797
47798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
47799   void * jresult ;
47800   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47801   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
47802
47803   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47804   {
47805     try {
47806       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
47807     } CALL_CATCH_EXCEPTION(0);
47808   }
47809
47810   jresult = (void *)result;
47811   return jresult;
47812 }
47813
47814
47815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
47816   void * jresult ;
47817   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47818   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
47819
47820   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47821   {
47822     try {
47823       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
47824     } CALL_CATCH_EXCEPTION(0);
47825   }
47826
47827   jresult = (void *)result;
47828   return jresult;
47829 }
47830
47831
47832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
47833   void * jresult ;
47834   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47835   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
47836
47837   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47838   {
47839     try {
47840       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
47841     } CALL_CATCH_EXCEPTION(0);
47842   }
47843
47844   jresult = (void *)result;
47845   return jresult;
47846 }
47847
47848
47849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
47850   void * jresult ;
47851   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47852   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
47853
47854   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47855   {
47856     try {
47857       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
47858     } CALL_CATCH_EXCEPTION(0);
47859   }
47860
47861   jresult = (void *)result;
47862   return jresult;
47863 }
47864
47865
47866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
47867   void * jresult ;
47868   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47869   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
47870
47871   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47872   {
47873     try {
47874       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
47875     } CALL_CATCH_EXCEPTION(0);
47876   }
47877
47878   jresult = (void *)result;
47879   return jresult;
47880 }
47881
47882
47883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
47884   void * jresult ;
47885   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47886   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
47887
47888   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47889   {
47890     try {
47891       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
47892     } CALL_CATCH_EXCEPTION(0);
47893   }
47894
47895   jresult = (void *)result;
47896   return jresult;
47897 }
47898
47899
47900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
47901   void * jresult ;
47902   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47903   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
47904
47905   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47906   {
47907     try {
47908       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
47909     } CALL_CATCH_EXCEPTION(0);
47910   }
47911
47912   jresult = (void *)result;
47913   return jresult;
47914 }
47915
47916
47917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
47918   void * jresult ;
47919   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47920   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
47921
47922   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47923   {
47924     try {
47925       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
47926     } CALL_CATCH_EXCEPTION(0);
47927   }
47928
47929   jresult = (void *)result;
47930   return jresult;
47931 }
47932
47933
47934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
47935   void * jresult ;
47936   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47937   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
47938
47939   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47940   {
47941     try {
47942       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
47943     } CALL_CATCH_EXCEPTION(0);
47944   }
47945
47946   jresult = (void *)result;
47947   return jresult;
47948 }
47949
47950
47951 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
47952   void * jresult ;
47953   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47954   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
47955
47956   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47957   {
47958     try {
47959       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
47960     } CALL_CATCH_EXCEPTION(0);
47961   }
47962
47963   jresult = (void *)result;
47964   return jresult;
47965 }
47966
47967
47968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
47969   void * jresult ;
47970   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47971   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
47972
47973   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47974   {
47975     try {
47976       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
47977     } CALL_CATCH_EXCEPTION(0);
47978   }
47979
47980   jresult = (void *)result;
47981   return jresult;
47982 }
47983
47984
47985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
47986   void * jresult ;
47987   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47988   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
47989
47990   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47991   {
47992     try {
47993       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
47994     } CALL_CATCH_EXCEPTION(0);
47995   }
47996
47997   jresult = (void *)result;
47998   return jresult;
47999 }
48000
48001
48002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
48003   void * jresult ;
48004   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48005   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
48006
48007   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48008   {
48009     try {
48010       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
48011     } CALL_CATCH_EXCEPTION(0);
48012   }
48013
48014   jresult = (void *)result;
48015   return jresult;
48016 }
48017
48018
48019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
48020   void * jresult ;
48021   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48022   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
48023
48024   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48025   {
48026     try {
48027       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
48028     } CALL_CATCH_EXCEPTION(0);
48029   }
48030
48031   jresult = (void *)result;
48032   return jresult;
48033 }
48034
48035
48036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
48037   void * jresult ;
48038   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48039   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
48040
48041   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48042   {
48043     try {
48044       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
48045     } CALL_CATCH_EXCEPTION(0);
48046   }
48047
48048   jresult = (void *)result;
48049   return jresult;
48050 }
48051
48052
48053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
48054   void * jresult ;
48055   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48056   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
48057
48058   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48059   {
48060     try {
48061       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
48062     } CALL_CATCH_EXCEPTION(0);
48063   }
48064
48065   jresult = (void *)result;
48066   return jresult;
48067 }
48068
48069
48070 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
48071   void * jresult ;
48072   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48073   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
48074
48075   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48076   {
48077     try {
48078       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
48079     } CALL_CATCH_EXCEPTION(0);
48080   }
48081
48082   jresult = (void *)result;
48083   return jresult;
48084 }
48085
48086
48087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
48088   void * jresult ;
48089   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48090   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
48091
48092   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48093   {
48094     try {
48095       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
48096     } CALL_CATCH_EXCEPTION(0);
48097   }
48098
48099   jresult = (void *)result;
48100   return jresult;
48101 }
48102
48103
48104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
48105   void * jresult ;
48106   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48107   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
48108
48109   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48110   {
48111     try {
48112       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
48113     } CALL_CATCH_EXCEPTION(0);
48114   }
48115
48116   jresult = (void *)result;
48117   return jresult;
48118 }
48119
48120
48121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
48122   void * jresult ;
48123   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48124   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
48125
48126   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48127   {
48128     try {
48129       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
48130     } CALL_CATCH_EXCEPTION(0);
48131   }
48132
48133   jresult = (void *)result;
48134   return jresult;
48135 }
48136
48137
48138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
48139   void * jresult ;
48140   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48141   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
48142
48143   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48144   {
48145     try {
48146       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
48147     } CALL_CATCH_EXCEPTION(0);
48148   }
48149
48150   jresult = (void *)result;
48151   return jresult;
48152 }
48153
48154
48155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
48156   void * jresult ;
48157   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48158   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
48159
48160   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48161   {
48162     try {
48163       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
48164     } CALL_CATCH_EXCEPTION(0);
48165   }
48166
48167   jresult = (void *)result;
48168   return jresult;
48169 }
48170
48171
48172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
48173   void * jresult ;
48174   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48175   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
48176
48177   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48178   {
48179     try {
48180       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
48181     } CALL_CATCH_EXCEPTION(0);
48182   }
48183
48184   jresult = (void *)result;
48185   return jresult;
48186 }
48187
48188
48189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
48190   void * jresult ;
48191   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48192   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
48193
48194   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48195   {
48196     try {
48197       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
48198     } CALL_CATCH_EXCEPTION(0);
48199   }
48200
48201   jresult = (void *)result;
48202   return jresult;
48203 }
48204
48205
48206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
48207   void * jresult ;
48208   Dali::Toolkit::StyleManager *result = 0 ;
48209
48210   {
48211     try {
48212       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
48213     } CALL_CATCH_EXCEPTION(0);
48214   }
48215
48216   jresult = (void *)result;
48217   return jresult;
48218 }
48219
48220
48221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
48222   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
48223
48224   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
48225   {
48226     try {
48227       delete arg1;
48228     } CALL_CATCH_EXCEPTION();
48229   }
48230
48231 }
48232
48233
48234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
48235   void * jresult ;
48236   Dali::Toolkit::StyleManager result;
48237
48238   {
48239     try {
48240       result = Dali::Toolkit::StyleManager::Get();
48241     } CALL_CATCH_EXCEPTION(0);
48242   }
48243
48244   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
48245   return jresult;
48246 }
48247
48248
48249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
48250   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
48251   std::string *arg2 = 0 ;
48252
48253   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
48254   if (!jarg2) {
48255     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
48256     return ;
48257   }
48258   std::string arg2_str(jarg2);
48259   arg2 = &arg2_str;
48260   {
48261     try {
48262       (arg1)->ApplyTheme((std::string const &)*arg2);
48263     } CALL_CATCH_EXCEPTION();
48264   }
48265
48266
48267   //argout typemap for const std::string&
48268
48269 }
48270
48271
48272 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
48273   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
48274
48275   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
48276   {
48277     try {
48278       (arg1)->ApplyDefaultTheme();
48279     } CALL_CATCH_EXCEPTION();
48280   }
48281
48282 }
48283
48284
48285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
48286   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
48287   std::string *arg2 = 0 ;
48288   Dali::Property::Value *arg3 = 0 ;
48289
48290   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
48291   if (!jarg2) {
48292     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
48293     return ;
48294   }
48295   std::string arg2_str(jarg2);
48296   arg2 = &arg2_str;
48297   arg3 = (Dali::Property::Value *)jarg3;
48298   if (!arg3) {
48299     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
48300     return ;
48301   }
48302   {
48303     try {
48304       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
48305     } CALL_CATCH_EXCEPTION();
48306   }
48307
48308
48309   //argout typemap for const std::string&
48310
48311 }
48312
48313
48314 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
48315   unsigned int jresult ;
48316   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
48317   std::string *arg2 = 0 ;
48318   Dali::Property::Value *arg3 = 0 ;
48319   bool result;
48320
48321   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
48322   if (!jarg2) {
48323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
48324     return 0;
48325   }
48326   std::string arg2_str(jarg2);
48327   arg2 = &arg2_str;
48328   arg3 = (Dali::Property::Value *)jarg3;
48329   if (!arg3) {
48330     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
48331     return 0;
48332   }
48333   {
48334     try {
48335       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
48336     } CALL_CATCH_EXCEPTION(0);
48337   }
48338
48339   jresult = result;
48340
48341   //argout typemap for const std::string&
48342
48343   return jresult;
48344 }
48345
48346
48347 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
48348   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
48349   Dali::Toolkit::Control arg2 ;
48350   std::string *arg3 = 0 ;
48351   std::string *arg4 = 0 ;
48352   Dali::Toolkit::Control *argp2 ;
48353
48354   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
48355   argp2 = (Dali::Toolkit::Control *)jarg2;
48356   if (!argp2) {
48357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
48358     return ;
48359   }
48360   arg2 = *argp2;
48361   if (!jarg3) {
48362     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
48363     return ;
48364   }
48365   std::string arg3_str(jarg3);
48366   arg3 = &arg3_str;
48367   if (!jarg4) {
48368     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
48369     return ;
48370   }
48371   std::string arg4_str(jarg4);
48372   arg4 = &arg4_str;
48373   {
48374     try {
48375       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
48376     } CALL_CATCH_EXCEPTION();
48377   }
48378
48379
48380   //argout typemap for const std::string&
48381
48382
48383   //argout typemap for const std::string&
48384
48385 }
48386
48387
48388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
48389   void * jresult ;
48390   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
48391   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
48392
48393   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
48394   {
48395     try {
48396       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
48397     } CALL_CATCH_EXCEPTION(0);
48398   }
48399
48400   jresult = (void *)result;
48401   return jresult;
48402 }
48403
48404
48405 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
48406   int jresult ;
48407   int result;
48408
48409   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
48410   jresult = (int)result;
48411   return jresult;
48412 }
48413
48414
48415 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
48416   int jresult ;
48417   int result;
48418
48419   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
48420   jresult = (int)result;
48421   return jresult;
48422 }
48423
48424
48425 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
48426   int jresult ;
48427   int result;
48428
48429   result = (int)Dali::Toolkit::Slider::Property::VALUE;
48430   jresult = (int)result;
48431   return jresult;
48432 }
48433
48434
48435 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
48436   int jresult ;
48437   int result;
48438
48439   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
48440   jresult = (int)result;
48441   return jresult;
48442 }
48443
48444
48445 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
48446   int jresult ;
48447   int result;
48448
48449   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
48450   jresult = (int)result;
48451   return jresult;
48452 }
48453
48454
48455 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
48456   int jresult ;
48457   int result;
48458
48459   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
48460   jresult = (int)result;
48461   return jresult;
48462 }
48463
48464
48465 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
48466   int jresult ;
48467   int result;
48468
48469   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
48470   jresult = (int)result;
48471   return jresult;
48472 }
48473
48474
48475 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
48476   int jresult ;
48477   int result;
48478
48479   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
48480   jresult = (int)result;
48481   return jresult;
48482 }
48483
48484
48485 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
48486   int jresult ;
48487   int result;
48488
48489   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
48490   jresult = (int)result;
48491   return jresult;
48492 }
48493
48494
48495 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
48496   int jresult ;
48497   int result;
48498
48499   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
48500   jresult = (int)result;
48501   return jresult;
48502 }
48503
48504
48505 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
48506   int jresult ;
48507   int result;
48508
48509   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
48510   jresult = (int)result;
48511   return jresult;
48512 }
48513
48514
48515 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
48516   int jresult ;
48517   int result;
48518
48519   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
48520   jresult = (int)result;
48521   return jresult;
48522 }
48523
48524
48525 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
48526   int jresult ;
48527   int result;
48528
48529   result = (int)Dali::Toolkit::Slider::Property::MARKS;
48530   jresult = (int)result;
48531   return jresult;
48532 }
48533
48534
48535 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
48536   int jresult ;
48537   int result;
48538
48539   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
48540   jresult = (int)result;
48541   return jresult;
48542 }
48543
48544
48545 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
48546   int jresult ;
48547   int result;
48548
48549   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
48550   jresult = (int)result;
48551   return jresult;
48552 }
48553
48554
48555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
48556   void * jresult ;
48557   Dali::Toolkit::Slider::Property *result = 0 ;
48558
48559   {
48560     try {
48561       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
48562     } CALL_CATCH_EXCEPTION(0);
48563   }
48564
48565   jresult = (void *)result;
48566   return jresult;
48567 }
48568
48569
48570 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
48571   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
48572
48573   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
48574   {
48575     try {
48576       delete arg1;
48577     } CALL_CATCH_EXCEPTION();
48578   }
48579
48580 }
48581
48582
48583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
48584   void * jresult ;
48585   Dali::Toolkit::Slider result;
48586
48587   {
48588     try {
48589       result = Dali::Toolkit::Slider::New();
48590     } CALL_CATCH_EXCEPTION(0);
48591   }
48592
48593   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
48594   return jresult;
48595 }
48596
48597
48598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
48599   void * jresult ;
48600   Dali::Toolkit::Slider *result = 0 ;
48601
48602   {
48603     try {
48604       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
48605     } CALL_CATCH_EXCEPTION(0);
48606   }
48607
48608   jresult = (void *)result;
48609   return jresult;
48610 }
48611
48612
48613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
48614   void * jresult ;
48615   Dali::Toolkit::Slider *arg1 = 0 ;
48616   Dali::Toolkit::Slider *result = 0 ;
48617
48618   arg1 = (Dali::Toolkit::Slider *)jarg1;
48619   if (!arg1) {
48620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
48621     return 0;
48622   }
48623   {
48624     try {
48625       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
48626     } CALL_CATCH_EXCEPTION(0);
48627   }
48628
48629   jresult = (void *)result;
48630   return jresult;
48631 }
48632
48633
48634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
48635   void * jresult ;
48636   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
48637   Dali::Toolkit::Slider *arg2 = 0 ;
48638   Dali::Toolkit::Slider *result = 0 ;
48639
48640   arg1 = (Dali::Toolkit::Slider *)jarg1;
48641   arg2 = (Dali::Toolkit::Slider *)jarg2;
48642   if (!arg2) {
48643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
48644     return 0;
48645   }
48646   {
48647     try {
48648       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
48649     } CALL_CATCH_EXCEPTION(0);
48650   }
48651
48652   jresult = (void *)result;
48653   return jresult;
48654 }
48655
48656
48657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
48658   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
48659
48660   arg1 = (Dali::Toolkit::Slider *)jarg1;
48661   {
48662     try {
48663       delete arg1;
48664     } CALL_CATCH_EXCEPTION();
48665   }
48666
48667 }
48668
48669
48670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
48671   void * jresult ;
48672   Dali::BaseHandle arg1 ;
48673   Dali::BaseHandle *argp1 ;
48674   Dali::Toolkit::Slider result;
48675
48676   argp1 = (Dali::BaseHandle *)jarg1;
48677   if (!argp1) {
48678     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
48679     return 0;
48680   }
48681   arg1 = *argp1;
48682   {
48683     try {
48684       result = Dali::Toolkit::Slider::DownCast(arg1);
48685     } CALL_CATCH_EXCEPTION(0);
48686   }
48687
48688   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
48689   return jresult;
48690 }
48691
48692
48693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
48694   void * jresult ;
48695   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
48696   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
48697
48698   arg1 = (Dali::Toolkit::Slider *)jarg1;
48699   {
48700     try {
48701       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
48702     } CALL_CATCH_EXCEPTION(0);
48703   }
48704
48705   jresult = (void *)result;
48706   return jresult;
48707 }
48708
48709
48710 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
48711   void * jresult ;
48712   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
48713   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
48714
48715   arg1 = (Dali::Toolkit::Slider *)jarg1;
48716   {
48717     try {
48718       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
48719     } CALL_CATCH_EXCEPTION(0);
48720   }
48721
48722   jresult = (void *)result;
48723   return jresult;
48724 }
48725
48726
48727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
48728   void * jresult ;
48729   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
48730   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
48731
48732   arg1 = (Dali::Toolkit::Slider *)jarg1;
48733   {
48734     try {
48735       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
48736     } CALL_CATCH_EXCEPTION(0);
48737   }
48738
48739   jresult = (void *)result;
48740   return jresult;
48741 }
48742
48743
48744 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
48745   int jresult ;
48746   int result;
48747
48748   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
48749   jresult = (int)result;
48750   return jresult;
48751 }
48752
48753
48754 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
48755   int jresult ;
48756   int result;
48757
48758   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
48759   jresult = (int)result;
48760   return jresult;
48761 }
48762
48763
48764 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
48765   int jresult ;
48766   int result;
48767
48768   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
48769   jresult = (int)result;
48770   return jresult;
48771 }
48772
48773
48774 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
48775   int jresult ;
48776   int result;
48777
48778   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
48779   jresult = (int)result;
48780   return jresult;
48781 }
48782
48783
48784 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_UNDERLAY_get() {
48785   int result;
48786
48787   result = (int)Dali::Toolkit::VideoView::Property::UNDERLAY;
48788
48789   return result;
48790 }
48791
48792
48793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
48794   void * jresult ;
48795   Dali::Toolkit::VideoView::Property *result = 0 ;
48796
48797   {
48798     try {
48799       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
48800     } CALL_CATCH_EXCEPTION(0);
48801   }
48802
48803   jresult = (void *)result;
48804   return jresult;
48805 }
48806
48807
48808 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
48809   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
48810
48811   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
48812   {
48813     try {
48814       delete arg1;
48815     } CALL_CATCH_EXCEPTION();
48816   }
48817
48818 }
48819
48820
48821 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
48822   void * jresult ;
48823   Dali::Toolkit::VideoView result;
48824
48825   {
48826     try {
48827       result = Dali::Toolkit::VideoView::New();
48828     } CALL_CATCH_EXCEPTION(0);
48829   }
48830
48831   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
48832   return jresult;
48833 }
48834
48835
48836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
48837   void * jresult ;
48838   std::string *arg1 = 0 ;
48839   Dali::Toolkit::VideoView result;
48840
48841   if (!jarg1) {
48842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
48843     return 0;
48844   }
48845   std::string arg1_str(jarg1);
48846   arg1 = &arg1_str;
48847   {
48848     try {
48849       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
48850     } CALL_CATCH_EXCEPTION(0);
48851   }
48852
48853   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
48854
48855   //argout typemap for const std::string&
48856
48857   return jresult;
48858 }
48859
48860
48861 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_2(bool swCodec) {
48862   void * jresult ;
48863   Dali::Toolkit::VideoView result;
48864   {
48865     try {
48866       result = Dali::Toolkit::VideoView::New(swCodec);
48867     } CALL_CATCH_EXCEPTION(0);
48868   }
48869
48870   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
48871
48872   //argout typemap for const std::string&
48873
48874   return jresult;
48875 }
48876
48877
48878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_3(char * jarg1, bool swCodec) {
48879   void * jresult ;
48880   std::string *arg1 = 0 ;
48881   Dali::Toolkit::VideoView result;
48882
48883   if (!jarg1) {
48884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
48885     return 0;
48886   }
48887   std::string arg1_str(jarg1);
48888   arg1 = &arg1_str;
48889   {
48890     try {
48891       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1, swCodec);
48892     } CALL_CATCH_EXCEPTION(0);
48893   }
48894
48895   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
48896
48897   //argout typemap for const std::string&
48898
48899   return jresult;
48900 }
48901
48902
48903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
48904   void * jresult ;
48905   Dali::Toolkit::VideoView *result = 0 ;
48906
48907   {
48908     try {
48909       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
48910     } CALL_CATCH_EXCEPTION(0);
48911   }
48912
48913   jresult = (void *)result;
48914   return jresult;
48915 }
48916
48917
48918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
48919   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
48920
48921   arg1 = (Dali::Toolkit::VideoView *)jarg1;
48922   {
48923     try {
48924       delete arg1;
48925     } CALL_CATCH_EXCEPTION();
48926   }
48927
48928 }
48929
48930
48931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
48932   void * jresult ;
48933   Dali::Toolkit::VideoView *arg1 = 0 ;
48934   Dali::Toolkit::VideoView *result = 0 ;
48935
48936   arg1 = (Dali::Toolkit::VideoView *)jarg1;
48937   if (!arg1) {
48938     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
48939     return 0;
48940   }
48941   {
48942     try {
48943       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
48944     } CALL_CATCH_EXCEPTION(0);
48945   }
48946
48947   jresult = (void *)result;
48948   return jresult;
48949 }
48950
48951
48952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
48953   void * jresult ;
48954   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
48955   Dali::Toolkit::VideoView *arg2 = 0 ;
48956   Dali::Toolkit::VideoView *result = 0 ;
48957
48958   arg1 = (Dali::Toolkit::VideoView *)jarg1;
48959   arg2 = (Dali::Toolkit::VideoView *)jarg2;
48960   if (!arg2) {
48961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
48962     return 0;
48963   }
48964   {
48965     try {
48966       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
48967     } CALL_CATCH_EXCEPTION(0);
48968   }
48969
48970   jresult = (void *)result;
48971   return jresult;
48972 }
48973
48974
48975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
48976   void * jresult ;
48977   Dali::BaseHandle arg1 ;
48978   Dali::BaseHandle *argp1 ;
48979   Dali::Toolkit::VideoView result;
48980
48981   argp1 = (Dali::BaseHandle *)jarg1;
48982   if (!argp1) {
48983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
48984     return 0;
48985   }
48986   arg1 = *argp1;
48987   {
48988     try {
48989       result = Dali::Toolkit::VideoView::DownCast(arg1);
48990     } CALL_CATCH_EXCEPTION(0);
48991   }
48992
48993   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
48994   return jresult;
48995 }
48996
48997
48998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
48999   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
49000
49001   arg1 = (Dali::Toolkit::VideoView *)jarg1;
49002   {
49003     try {
49004       (arg1)->Play();
49005     } CALL_CATCH_EXCEPTION();
49006   }
49007
49008 }
49009
49010
49011 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
49012   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
49013
49014   arg1 = (Dali::Toolkit::VideoView *)jarg1;
49015   {
49016     try {
49017       (arg1)->Pause();
49018     } CALL_CATCH_EXCEPTION();
49019   }
49020
49021 }
49022
49023
49024 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
49025   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
49026
49027   arg1 = (Dali::Toolkit::VideoView *)jarg1;
49028   {
49029     try {
49030       (arg1)->Stop();
49031     } CALL_CATCH_EXCEPTION();
49032   }
49033
49034 }
49035
49036
49037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
49038   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
49039   int arg2 ;
49040
49041   arg1 = (Dali::Toolkit::VideoView *)jarg1;
49042   arg2 = (int)jarg2;
49043   {
49044     try {
49045       (arg1)->Forward(arg2);
49046     } CALL_CATCH_EXCEPTION();
49047   }
49048
49049 }
49050
49051
49052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
49053   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
49054   int arg2 ;
49055
49056   arg1 = (Dali::Toolkit::VideoView *)jarg1;
49057   arg2 = (int)jarg2;
49058   {
49059     try {
49060       (arg1)->Backward(arg2);
49061     } CALL_CATCH_EXCEPTION();
49062   }
49063
49064 }
49065
49066
49067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
49068   void * jresult ;
49069   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
49070   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
49071
49072   arg1 = (Dali::Toolkit::VideoView *)jarg1;
49073   {
49074     try {
49075       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
49076     } CALL_CATCH_EXCEPTION(0);
49077   }
49078
49079   jresult = (void *)result;
49080   return jresult;
49081 }
49082
49083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_GetNativePlayerHandle( void * jarg1 )
49084 {
49085   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *)jarg1;
49086   if( arg1 == nullptr )
49087   {
49088     DALI_LOG_ERROR("VideoView is nullptr!");
49089     return nullptr;
49090   }
49091   void * ret = nullptr;
49092   {
49093     try{
49094
49095       Dali::Any result = Toolkit::DevelVideoView::GetMediaPlayer( *arg1 );
49096       ret = Dali::AnyCast< void * >( result );
49097
49098     } CALL_CATCH_EXCEPTION(0);
49099   }
49100   return ret;
49101 }
49102
49103
49104 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
49105   int jresult ;
49106   int result;
49107
49108   result = (int)Dali::Toolkit::Popup::Property::TITLE;
49109   jresult = (int)result;
49110   return jresult;
49111 }
49112
49113
49114 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
49115   int jresult ;
49116   int result;
49117
49118   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
49119   jresult = (int)result;
49120   return jresult;
49121 }
49122
49123
49124 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
49125   int jresult ;
49126   int result;
49127
49128   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
49129   jresult = (int)result;
49130   return jresult;
49131 }
49132
49133
49134 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
49135   int jresult ;
49136   int result;
49137
49138   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
49139   jresult = (int)result;
49140   return jresult;
49141 }
49142
49143
49144 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
49145   int jresult ;
49146   int result;
49147
49148   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
49149   jresult = (int)result;
49150   return jresult;
49151 }
49152
49153
49154 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
49155   int jresult ;
49156   int result;
49157
49158   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
49159   jresult = (int)result;
49160   return jresult;
49161 }
49162
49163
49164 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
49165   int jresult ;
49166   int result;
49167
49168   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
49169   jresult = (int)result;
49170   return jresult;
49171 }
49172
49173
49174 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
49175   int jresult ;
49176   int result;
49177
49178   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
49179   jresult = (int)result;
49180   return jresult;
49181 }
49182
49183
49184 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
49185   int jresult ;
49186   int result;
49187
49188   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
49189   jresult = (int)result;
49190   return jresult;
49191 }
49192
49193
49194 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
49195   int jresult ;
49196   int result;
49197
49198   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
49199   jresult = (int)result;
49200   return jresult;
49201 }
49202
49203
49204 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
49205   int jresult ;
49206   int result;
49207
49208   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
49209   jresult = (int)result;
49210   return jresult;
49211 }
49212
49213
49214 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
49215   int jresult ;
49216   int result;
49217
49218   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
49219   jresult = (int)result;
49220   return jresult;
49221 }
49222
49223
49224 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
49225   int jresult ;
49226   int result;
49227
49228   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
49229   jresult = (int)result;
49230   return jresult;
49231 }
49232
49233
49234 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
49235   int jresult ;
49236   int result;
49237
49238   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
49239   jresult = (int)result;
49240   return jresult;
49241 }
49242
49243
49244 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
49245   int jresult ;
49246   int result;
49247
49248   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
49249   jresult = (int)result;
49250   return jresult;
49251 }
49252
49253
49254 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
49255   int jresult ;
49256   int result;
49257
49258   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
49259   jresult = (int)result;
49260   return jresult;
49261 }
49262
49263
49264 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
49265   int jresult ;
49266   int result;
49267
49268   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
49269   jresult = (int)result;
49270   return jresult;
49271 }
49272
49273
49274 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
49275   int jresult ;
49276   int result;
49277
49278   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
49279   jresult = (int)result;
49280   return jresult;
49281 }
49282
49283
49284 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
49285   int jresult ;
49286   int result;
49287
49288   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
49289   jresult = (int)result;
49290   return jresult;
49291 }
49292
49293
49294 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
49295   int jresult ;
49296   int result;
49297
49298   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
49299   jresult = (int)result;
49300   return jresult;
49301 }
49302
49303
49304 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
49305   int jresult ;
49306   int result;
49307
49308   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
49309   jresult = (int)result;
49310   return jresult;
49311 }
49312
49313
49314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
49315   void * jresult ;
49316   Dali::Toolkit::Popup::Property *result = 0 ;
49317
49318   {
49319     try {
49320       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
49321     } CALL_CATCH_EXCEPTION(0);
49322   }
49323
49324   jresult = (void *)result;
49325   return jresult;
49326 }
49327
49328
49329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
49330   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
49331
49332   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
49333   {
49334     try {
49335       delete arg1;
49336     } CALL_CATCH_EXCEPTION();
49337   }
49338
49339 }
49340
49341
49342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
49343   void * jresult ;
49344   Dali::Toolkit::Popup *result = 0 ;
49345
49346   {
49347     try {
49348       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
49349     } CALL_CATCH_EXCEPTION(0);
49350   }
49351
49352   jresult = (void *)result;
49353   return jresult;
49354 }
49355
49356
49357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
49358   void * jresult ;
49359   Dali::Toolkit::Popup result;
49360
49361   {
49362     try {
49363       result = Dali::Toolkit::Popup::New();
49364     } CALL_CATCH_EXCEPTION(0);
49365   }
49366
49367   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
49368   return jresult;
49369 }
49370
49371
49372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
49373   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
49374
49375   arg1 = (Dali::Toolkit::Popup *)jarg1;
49376   {
49377     try {
49378       delete arg1;
49379     } CALL_CATCH_EXCEPTION();
49380   }
49381
49382 }
49383
49384
49385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
49386   void * jresult ;
49387   Dali::Toolkit::Popup *arg1 = 0 ;
49388   Dali::Toolkit::Popup *result = 0 ;
49389
49390   arg1 = (Dali::Toolkit::Popup *)jarg1;
49391   if (!arg1) {
49392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
49393     return 0;
49394   }
49395   {
49396     try {
49397       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
49398     } CALL_CATCH_EXCEPTION(0);
49399   }
49400
49401   jresult = (void *)result;
49402   return jresult;
49403 }
49404
49405
49406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
49407   void * jresult ;
49408   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
49409   Dali::Toolkit::Popup *arg2 = 0 ;
49410   Dali::Toolkit::Popup *result = 0 ;
49411
49412   arg1 = (Dali::Toolkit::Popup *)jarg1;
49413   arg2 = (Dali::Toolkit::Popup *)jarg2;
49414   if (!arg2) {
49415     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
49416     return 0;
49417   }
49418   {
49419     try {
49420       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
49421     } CALL_CATCH_EXCEPTION(0);
49422   }
49423
49424   jresult = (void *)result;
49425   return jresult;
49426 }
49427
49428
49429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
49430   void * jresult ;
49431   Dali::BaseHandle arg1 ;
49432   Dali::BaseHandle *argp1 ;
49433   Dali::Toolkit::Popup result;
49434
49435   argp1 = (Dali::BaseHandle *)jarg1;
49436   if (!argp1) {
49437     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
49438     return 0;
49439   }
49440   arg1 = *argp1;
49441   {
49442     try {
49443       result = Dali::Toolkit::Popup::DownCast(arg1);
49444     } CALL_CATCH_EXCEPTION(0);
49445   }
49446
49447   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
49448   return jresult;
49449 }
49450
49451
49452 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
49453   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
49454   Dali::Actor arg2 ;
49455   Dali::Actor *argp2 ;
49456
49457   arg1 = (Dali::Toolkit::Popup *)jarg1;
49458   argp2 = (Dali::Actor *)jarg2;
49459   if (!argp2) {
49460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
49461     return ;
49462   }
49463   arg2 = *argp2;
49464   {
49465     try {
49466       (arg1)->SetTitle(arg2);
49467     } CALL_CATCH_EXCEPTION();
49468   }
49469
49470 }
49471
49472
49473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
49474   void * jresult ;
49475   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
49476   Dali::Actor result;
49477
49478   arg1 = (Dali::Toolkit::Popup *)jarg1;
49479   {
49480     try {
49481       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
49482     } CALL_CATCH_EXCEPTION(0);
49483   }
49484
49485   jresult = new Dali::Actor((const Dali::Actor &)result);
49486   return jresult;
49487 }
49488
49489
49490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
49491   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
49492   Dali::Actor arg2 ;
49493   Dali::Actor *argp2 ;
49494
49495   arg1 = (Dali::Toolkit::Popup *)jarg1;
49496   argp2 = (Dali::Actor *)jarg2;
49497   if (!argp2) {
49498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
49499     return ;
49500   }
49501   arg2 = *argp2;
49502   {
49503     try {
49504       (arg1)->SetContent(arg2);
49505     } CALL_CATCH_EXCEPTION();
49506   }
49507
49508 }
49509
49510
49511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
49512   void * jresult ;
49513   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
49514   Dali::Actor result;
49515
49516   arg1 = (Dali::Toolkit::Popup *)jarg1;
49517   {
49518     try {
49519       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
49520     } CALL_CATCH_EXCEPTION(0);
49521   }
49522
49523   jresult = new Dali::Actor((const Dali::Actor &)result);
49524   return jresult;
49525 }
49526
49527
49528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
49529   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
49530   Dali::Actor arg2 ;
49531   Dali::Actor *argp2 ;
49532
49533   arg1 = (Dali::Toolkit::Popup *)jarg1;
49534   argp2 = (Dali::Actor *)jarg2;
49535   if (!argp2) {
49536     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
49537     return ;
49538   }
49539   arg2 = *argp2;
49540   {
49541     try {
49542       (arg1)->SetFooter(arg2);
49543     } CALL_CATCH_EXCEPTION();
49544   }
49545
49546 }
49547
49548
49549 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
49550   void * jresult ;
49551   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
49552   Dali::Actor result;
49553
49554   arg1 = (Dali::Toolkit::Popup *)jarg1;
49555   {
49556     try {
49557       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
49558     } CALL_CATCH_EXCEPTION(0);
49559   }
49560
49561   jresult = new Dali::Actor((const Dali::Actor &)result);
49562   return jresult;
49563 }
49564
49565
49566 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
49567   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
49568   Dali::Toolkit::Popup::DisplayState arg2 ;
49569
49570   arg1 = (Dali::Toolkit::Popup *)jarg1;
49571   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
49572   {
49573     try {
49574       (arg1)->SetDisplayState(arg2);
49575     } CALL_CATCH_EXCEPTION();
49576   }
49577
49578 }
49579
49580
49581 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
49582   int jresult ;
49583   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
49584   Dali::Toolkit::Popup::DisplayState result;
49585
49586   arg1 = (Dali::Toolkit::Popup *)jarg1;
49587   {
49588     try {
49589       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
49590     } CALL_CATCH_EXCEPTION(0);
49591   }
49592
49593   jresult = (int)result;
49594   return jresult;
49595 }
49596
49597
49598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
49599   void * jresult ;
49600   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
49601   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
49602
49603   arg1 = (Dali::Toolkit::Popup *)jarg1;
49604   {
49605     try {
49606       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
49607     } CALL_CATCH_EXCEPTION(0);
49608   }
49609
49610   jresult = (void *)result;
49611   return jresult;
49612 }
49613
49614
49615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
49616   void * jresult ;
49617   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
49618   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
49619
49620   arg1 = (Dali::Toolkit::Popup *)jarg1;
49621   {
49622     try {
49623       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
49624     } CALL_CATCH_EXCEPTION(0);
49625   }
49626
49627   jresult = (void *)result;
49628   return jresult;
49629 }
49630
49631
49632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
49633   void * jresult ;
49634   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
49635   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
49636
49637   arg1 = (Dali::Toolkit::Popup *)jarg1;
49638   {
49639     try {
49640       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
49641     } CALL_CATCH_EXCEPTION(0);
49642   }
49643
49644   jresult = (void *)result;
49645   return jresult;
49646 }
49647
49648
49649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
49650   void * jresult ;
49651   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
49652   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
49653
49654   arg1 = (Dali::Toolkit::Popup *)jarg1;
49655   {
49656     try {
49657       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
49658     } CALL_CATCH_EXCEPTION(0);
49659   }
49660
49661   jresult = (void *)result;
49662   return jresult;
49663 }
49664
49665
49666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
49667   void * jresult ;
49668   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
49669   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
49670
49671   arg1 = (Dali::Toolkit::Popup *)jarg1;
49672   {
49673     try {
49674       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
49675     } CALL_CATCH_EXCEPTION(0);
49676   }
49677
49678   jresult = (void *)result;
49679   return jresult;
49680 }
49681
49682
49683 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
49684   int jresult ;
49685   int result;
49686
49687   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
49688   jresult = (int)result;
49689   return jresult;
49690 }
49691
49692
49693 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
49694   int jresult ;
49695   int result;
49696
49697   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
49698   jresult = (int)result;
49699   return jresult;
49700 }
49701
49702
49703 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
49704   int jresult ;
49705   int result;
49706
49707   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
49708   jresult = (int)result;
49709   return jresult;
49710 }
49711
49712
49713 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
49714   int jresult ;
49715   int result;
49716
49717   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
49718   jresult = (int)result;
49719   return jresult;
49720 }
49721
49722
49723 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
49724   int jresult ;
49725   int result;
49726
49727   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
49728   jresult = (int)result;
49729   return jresult;
49730 }
49731
49732
49733 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
49734   int jresult ;
49735   int result;
49736
49737   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
49738   jresult = (int)result;
49739   return jresult;
49740 }
49741
49742
49743 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
49744   int jresult ;
49745   int result;
49746
49747   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
49748   jresult = (int)result;
49749   return jresult;
49750 }
49751
49752
49753 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
49754   int jresult ;
49755   int result;
49756
49757   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
49758   jresult = (int)result;
49759   return jresult;
49760 }
49761
49762
49763 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
49764   int jresult ;
49765   int result;
49766
49767   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
49768   jresult = (int)result;
49769   return jresult;
49770 }
49771
49772
49773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
49774   void * jresult ;
49775   Dali::Toolkit::ProgressBar::Property *result = 0 ;
49776
49777   {
49778     try {
49779       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
49780     } CALL_CATCH_EXCEPTION(0);
49781   }
49782
49783   jresult = (void *)result;
49784   return jresult;
49785 }
49786
49787
49788 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
49789   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
49790
49791   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
49792   {
49793     try {
49794       delete arg1;
49795     } CALL_CATCH_EXCEPTION();
49796   }
49797
49798 }
49799
49800
49801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
49802   void * jresult ;
49803   Dali::Toolkit::ProgressBar result;
49804
49805   {
49806     try {
49807       result = Dali::Toolkit::ProgressBar::New();
49808     } CALL_CATCH_EXCEPTION(0);
49809   }
49810
49811   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
49812   return jresult;
49813 }
49814
49815
49816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
49817   void * jresult ;
49818   Dali::Toolkit::ProgressBar *result = 0 ;
49819
49820   {
49821     try {
49822       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
49823     } CALL_CATCH_EXCEPTION(0);
49824   }
49825
49826   jresult = (void *)result;
49827   return jresult;
49828 }
49829
49830
49831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
49832   void * jresult ;
49833   Dali::Toolkit::ProgressBar *arg1 = 0 ;
49834   Dali::Toolkit::ProgressBar *result = 0 ;
49835
49836   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
49837   if (!arg1) {
49838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
49839     return 0;
49840   }
49841   {
49842     try {
49843       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
49844     } CALL_CATCH_EXCEPTION(0);
49845   }
49846
49847   jresult = (void *)result;
49848   return jresult;
49849 }
49850
49851
49852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
49853   void * jresult ;
49854   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
49855   Dali::Toolkit::ProgressBar *arg2 = 0 ;
49856   Dali::Toolkit::ProgressBar *result = 0 ;
49857
49858   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
49859   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
49860   if (!arg2) {
49861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
49862     return 0;
49863   }
49864   {
49865     try {
49866       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
49867     } CALL_CATCH_EXCEPTION(0);
49868   }
49869
49870   jresult = (void *)result;
49871   return jresult;
49872 }
49873
49874
49875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
49876   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
49877
49878   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
49879   {
49880     try {
49881       delete arg1;
49882     } CALL_CATCH_EXCEPTION();
49883   }
49884
49885 }
49886
49887
49888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
49889   void * jresult ;
49890   Dali::BaseHandle arg1 ;
49891   Dali::BaseHandle *argp1 ;
49892   Dali::Toolkit::ProgressBar result;
49893
49894   argp1 = (Dali::BaseHandle *)jarg1;
49895   if (!argp1) {
49896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
49897     return 0;
49898   }
49899   arg1 = *argp1;
49900   {
49901     try {
49902       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
49903     } CALL_CATCH_EXCEPTION(0);
49904   }
49905
49906   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
49907   return jresult;
49908 }
49909
49910
49911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
49912   void * jresult ;
49913   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
49914   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
49915
49916   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
49917   {
49918     try {
49919       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
49920     } CALL_CATCH_EXCEPTION(0);
49921   }
49922
49923   jresult = (void *)result;
49924   return jresult;
49925 }
49926
49927
49928 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
49929   void * jresult ;
49930   Dali::Toolkit::GaussianBlurView *result = 0 ;
49931
49932   {
49933     try {
49934       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
49935     } CALL_CATCH_EXCEPTION(0);
49936   }
49937
49938   jresult = (void *)result;
49939   return jresult;
49940 }
49941
49942
49943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
49944   void * jresult ;
49945   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
49946   Dali::Toolkit::GaussianBlurView *result = 0 ;
49947
49948   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
49949   if (!arg1) {
49950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
49951     return 0;
49952   }
49953   {
49954     try {
49955       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
49956     } CALL_CATCH_EXCEPTION(0);
49957   }
49958
49959   jresult = (void *)result;
49960   return jresult;
49961 }
49962
49963
49964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
49965   void * jresult ;
49966   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
49967   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
49968   Dali::Toolkit::GaussianBlurView *result = 0 ;
49969
49970   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
49971   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
49972   if (!arg2) {
49973     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
49974     return 0;
49975   }
49976   {
49977     try {
49978       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
49979     } CALL_CATCH_EXCEPTION(0);
49980   }
49981
49982   jresult = (void *)result;
49983   return jresult;
49984 }
49985
49986
49987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
49988   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
49989
49990   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
49991   {
49992     try {
49993       delete arg1;
49994     } CALL_CATCH_EXCEPTION();
49995   }
49996
49997 }
49998
49999
50000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
50001   void * jresult ;
50002   Dali::BaseHandle arg1 ;
50003   Dali::BaseHandle *argp1 ;
50004   Dali::Toolkit::GaussianBlurView result;
50005
50006   argp1 = (Dali::BaseHandle *)jarg1;
50007   if (!argp1) {
50008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
50009     return 0;
50010   }
50011   arg1 = *argp1;
50012   {
50013     try {
50014       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
50015     } CALL_CATCH_EXCEPTION(0);
50016   }
50017
50018   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
50019   return jresult;
50020 }
50021
50022
50023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
50024   void * jresult ;
50025   Dali::Toolkit::GaussianBlurView result;
50026
50027   {
50028     try {
50029       result = Dali::Toolkit::GaussianBlurView::New();
50030     } CALL_CATCH_EXCEPTION(0);
50031   }
50032
50033   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
50034   return jresult;
50035 }
50036
50037
50038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
50039   void * jresult ;
50040   unsigned int arg1 ;
50041   float arg2 ;
50042   Dali::Pixel::Format arg3 ;
50043   float arg4 ;
50044   float arg5 ;
50045   bool arg6 ;
50046   Dali::Toolkit::GaussianBlurView result;
50047
50048   arg1 = (unsigned int)jarg1;
50049   arg2 = (float)jarg2;
50050   arg3 = (Dali::Pixel::Format)jarg3;
50051   arg4 = (float)jarg4;
50052   arg5 = (float)jarg5;
50053   arg6 = jarg6 ? true : false;
50054   {
50055     try {
50056       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
50057     } CALL_CATCH_EXCEPTION(0);
50058   }
50059
50060   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
50061   return jresult;
50062 }
50063
50064
50065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
50066   void * jresult ;
50067   unsigned int arg1 ;
50068   float arg2 ;
50069   Dali::Pixel::Format arg3 ;
50070   float arg4 ;
50071   float arg5 ;
50072   Dali::Toolkit::GaussianBlurView result;
50073
50074   arg1 = (unsigned int)jarg1;
50075   arg2 = (float)jarg2;
50076   arg3 = (Dali::Pixel::Format)jarg3;
50077   arg4 = (float)jarg4;
50078   arg5 = (float)jarg5;
50079   {
50080     try {
50081       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
50082     } CALL_CATCH_EXCEPTION(0);
50083   }
50084
50085   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
50086   return jresult;
50087 }
50088
50089
50090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
50091   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
50092   Dali::Actor arg2 ;
50093   Dali::Actor *argp2 ;
50094
50095   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
50096   argp2 = (Dali::Actor *)jarg2;
50097   if (!argp2) {
50098     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50099     return ;
50100   }
50101   arg2 = *argp2;
50102   {
50103     try {
50104       (arg1)->Add(arg2);
50105     } CALL_CATCH_EXCEPTION();
50106   }
50107
50108 }
50109
50110
50111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
50112   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
50113   Dali::Actor arg2 ;
50114   Dali::Actor *argp2 ;
50115
50116   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
50117   argp2 = (Dali::Actor *)jarg2;
50118   if (!argp2) {
50119     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50120     return ;
50121   }
50122   arg2 = *argp2;
50123   {
50124     try {
50125       (arg1)->Remove(arg2);
50126     } CALL_CATCH_EXCEPTION();
50127   }
50128
50129 }
50130
50131
50132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
50133   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
50134
50135   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
50136   {
50137     try {
50138       (arg1)->Activate();
50139     } CALL_CATCH_EXCEPTION();
50140   }
50141
50142 }
50143
50144
50145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
50146   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
50147
50148   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
50149   {
50150     try {
50151       (arg1)->ActivateOnce();
50152     } CALL_CATCH_EXCEPTION();
50153   }
50154
50155 }
50156
50157
50158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
50159   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
50160
50161   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
50162   {
50163     try {
50164       (arg1)->Deactivate();
50165     } CALL_CATCH_EXCEPTION();
50166   }
50167
50168 }
50169
50170
50171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
50172   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
50173   Dali::Texture arg2 ;
50174   Dali::FrameBuffer arg3 ;
50175   Dali::Texture *argp2 ;
50176   Dali::FrameBuffer *argp3 ;
50177
50178   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
50179   argp2 = (Dali::Texture *)jarg2;
50180   if (!argp2) {
50181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
50182     return ;
50183   }
50184   arg2 = *argp2;
50185   argp3 = (Dali::FrameBuffer *)jarg3;
50186   if (!argp3) {
50187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
50188     return ;
50189   }
50190   arg3 = *argp3;
50191   {
50192     try {
50193       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
50194     } CALL_CATCH_EXCEPTION();
50195   }
50196
50197 }
50198
50199
50200 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
50201   int jresult ;
50202   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
50203   Dali::Property::Index result;
50204
50205   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
50206   {
50207     try {
50208       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
50209     } CALL_CATCH_EXCEPTION(0);
50210   }
50211
50212   jresult = result;
50213   return jresult;
50214 }
50215
50216
50217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
50218   void * jresult ;
50219   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
50220   Dali::FrameBuffer result;
50221
50222   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
50223   {
50224     try {
50225       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
50226     } CALL_CATCH_EXCEPTION(0);
50227   }
50228
50229   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
50230   return jresult;
50231 }
50232
50233
50234 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
50235   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
50236   Dali::Vector4 *arg2 = 0 ;
50237
50238   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
50239   arg2 = (Dali::Vector4 *)jarg2;
50240   if (!arg2) {
50241     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
50242     return ;
50243   }
50244   {
50245     try {
50246       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
50247     } CALL_CATCH_EXCEPTION();
50248   }
50249
50250 }
50251
50252
50253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
50254   void * jresult ;
50255   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
50256   Dali::Vector4 result;
50257
50258   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
50259   {
50260     try {
50261       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
50262     } CALL_CATCH_EXCEPTION(0);
50263   }
50264
50265   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
50266   return jresult;
50267 }
50268
50269
50270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
50271   void * jresult ;
50272   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
50273   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
50274
50275   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
50276   {
50277     try {
50278       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
50279     } CALL_CATCH_EXCEPTION(0);
50280   }
50281
50282   jresult = (void *)result;
50283   return jresult;
50284 }
50285
50286
50287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
50288   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
50289
50290   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
50291   {
50292     try {
50293       delete arg1;
50294     } CALL_CATCH_EXCEPTION();
50295   }
50296
50297 }
50298
50299
50300 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
50301   unsigned int jresult ;
50302   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
50303   unsigned int result;
50304
50305   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
50306   {
50307     try {
50308       result = (unsigned int)(arg1)->GetNumberOfPages();
50309     } CALL_CATCH_EXCEPTION(0);
50310   }
50311
50312   jresult = result;
50313   return jresult;
50314 }
50315
50316
50317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
50318   void * jresult ;
50319   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
50320   unsigned int arg2 ;
50321   Dali::Texture result;
50322
50323   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
50324   arg2 = (unsigned int)jarg2;
50325   {
50326     try {
50327       result = (arg1)->NewPage(arg2);
50328     } CALL_CATCH_EXCEPTION(0);
50329   }
50330
50331   jresult = new Dali::Texture((const Dali::Texture &)result);
50332   return jresult;
50333 }
50334
50335
50336 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_VIEW_PAGE_SIZE_get() {
50337   int jresult ;
50338   int result;
50339
50340   result = (int)Dali::Toolkit::PageTurnView::Property::VIEW_PAGE_SIZE;
50341   jresult = (int)result;
50342   return jresult;
50343 }
50344
50345
50346 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
50347   int jresult ;
50348   int result;
50349
50350   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
50351   jresult = (int)result;
50352   return jresult;
50353 }
50354
50355
50356 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
50357   int jresult ;
50358   int result;
50359
50360   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
50361   jresult = (int)result;
50362   return jresult;
50363 }
50364
50365
50366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
50367   void * jresult ;
50368   Dali::Toolkit::PageTurnView::Property *result = 0 ;
50369
50370   {
50371     try {
50372       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
50373     } CALL_CATCH_EXCEPTION(0);
50374   }
50375
50376   jresult = (void *)result;
50377   return jresult;
50378 }
50379
50380
50381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
50382   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
50383
50384   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
50385   {
50386     try {
50387       delete arg1;
50388     } CALL_CATCH_EXCEPTION();
50389   }
50390
50391 }
50392
50393
50394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
50395   void * jresult ;
50396   Dali::Toolkit::PageTurnView *result = 0 ;
50397
50398   {
50399     try {
50400       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
50401     } CALL_CATCH_EXCEPTION(0);
50402   }
50403
50404   jresult = (void *)result;
50405   return jresult;
50406 }
50407
50408
50409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
50410   void * jresult ;
50411   Dali::Toolkit::PageTurnView *arg1 = 0 ;
50412   Dali::Toolkit::PageTurnView *result = 0 ;
50413
50414   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
50415   if (!arg1) {
50416     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
50417     return 0;
50418   }
50419   {
50420     try {
50421       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
50422     } CALL_CATCH_EXCEPTION(0);
50423   }
50424
50425   jresult = (void *)result;
50426   return jresult;
50427 }
50428
50429
50430 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
50431   void * jresult ;
50432   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
50433   Dali::Toolkit::PageTurnView *arg2 = 0 ;
50434   Dali::Toolkit::PageTurnView *result = 0 ;
50435
50436   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
50437   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
50438   if (!arg2) {
50439     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
50440     return 0;
50441   }
50442   {
50443     try {
50444       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
50445     } CALL_CATCH_EXCEPTION(0);
50446   }
50447
50448   jresult = (void *)result;
50449   return jresult;
50450 }
50451
50452
50453 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
50454   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
50455
50456   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
50457   {
50458     try {
50459       delete arg1;
50460     } CALL_CATCH_EXCEPTION();
50461   }
50462
50463 }
50464
50465
50466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
50467   void * jresult ;
50468   Dali::BaseHandle arg1 ;
50469   Dali::BaseHandle *argp1 ;
50470   Dali::Toolkit::PageTurnView result;
50471
50472   argp1 = (Dali::BaseHandle *)jarg1;
50473   if (!argp1) {
50474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
50475     return 0;
50476   }
50477   arg1 = *argp1;
50478   {
50479     try {
50480       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
50481     } CALL_CATCH_EXCEPTION(0);
50482   }
50483
50484   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
50485   return jresult;
50486 }
50487
50488
50489 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
50490   void * jresult ;
50491   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
50492   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
50493
50494   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
50495   {
50496     try {
50497       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
50498     } CALL_CATCH_EXCEPTION(0);
50499   }
50500
50501   jresult = (void *)result;
50502   return jresult;
50503 }
50504
50505
50506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
50507   void * jresult ;
50508   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
50509   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
50510
50511   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
50512   {
50513     try {
50514       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
50515     } CALL_CATCH_EXCEPTION(0);
50516   }
50517
50518   jresult = (void *)result;
50519   return jresult;
50520 }
50521
50522
50523 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
50524   void * jresult ;
50525   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
50526   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
50527
50528   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
50529   {
50530     try {
50531       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
50532     } CALL_CATCH_EXCEPTION(0);
50533   }
50534
50535   jresult = (void *)result;
50536   return jresult;
50537 }
50538
50539
50540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
50541   void * jresult ;
50542   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
50543   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
50544
50545   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
50546   {
50547     try {
50548       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
50549     } CALL_CATCH_EXCEPTION(0);
50550   }
50551
50552   jresult = (void *)result;
50553   return jresult;
50554 }
50555
50556
50557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
50558   void * jresult ;
50559   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
50560
50561   {
50562     try {
50563       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
50564     } CALL_CATCH_EXCEPTION(0);
50565   }
50566
50567   jresult = (void *)result;
50568   return jresult;
50569 }
50570
50571
50572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
50573   void * jresult ;
50574   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
50575   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
50576
50577   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
50578   if (!arg1) {
50579     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
50580     return 0;
50581   }
50582   {
50583     try {
50584       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
50585     } CALL_CATCH_EXCEPTION(0);
50586   }
50587
50588   jresult = (void *)result;
50589   return jresult;
50590 }
50591
50592
50593 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
50594   void * jresult ;
50595   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
50596   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
50597   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
50598
50599   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
50600   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
50601   if (!arg2) {
50602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
50603     return 0;
50604   }
50605   {
50606     try {
50607       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
50608     } CALL_CATCH_EXCEPTION(0);
50609   }
50610
50611   jresult = (void *)result;
50612   return jresult;
50613 }
50614
50615
50616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
50617   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
50618
50619   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
50620   {
50621     try {
50622       delete arg1;
50623     } CALL_CATCH_EXCEPTION();
50624   }
50625
50626 }
50627
50628
50629 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
50630   void * jresult ;
50631   Dali::Toolkit::PageFactory *arg1 = 0 ;
50632   Dali::Vector2 *arg2 = 0 ;
50633   Dali::Toolkit::PageTurnLandscapeView result;
50634
50635   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
50636   if (!arg1) {
50637     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
50638     return 0;
50639   }
50640   arg2 = (Dali::Vector2 *)jarg2;
50641   if (!arg2) {
50642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
50643     return 0;
50644   }
50645   {
50646     try {
50647       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
50648     } CALL_CATCH_EXCEPTION(0);
50649   }
50650
50651   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
50652   return jresult;
50653 }
50654
50655
50656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
50657   void * jresult ;
50658   Dali::BaseHandle arg1 ;
50659   Dali::BaseHandle *argp1 ;
50660   Dali::Toolkit::PageTurnLandscapeView result;
50661
50662   argp1 = (Dali::BaseHandle *)jarg1;
50663   if (!argp1) {
50664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
50665     return 0;
50666   }
50667   arg1 = *argp1;
50668   {
50669     try {
50670       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
50671     } CALL_CATCH_EXCEPTION(0);
50672   }
50673
50674   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
50675   return jresult;
50676 }
50677
50678
50679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
50680   void * jresult ;
50681   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
50682
50683   {
50684     try {
50685       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
50686     } CALL_CATCH_EXCEPTION(0);
50687   }
50688
50689   jresult = (void *)result;
50690   return jresult;
50691 }
50692
50693
50694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
50695   void * jresult ;
50696   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
50697   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
50698
50699   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
50700   if (!arg1) {
50701     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
50702     return 0;
50703   }
50704   {
50705     try {
50706       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
50707     } CALL_CATCH_EXCEPTION(0);
50708   }
50709
50710   jresult = (void *)result;
50711   return jresult;
50712 }
50713
50714
50715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
50716   void * jresult ;
50717   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
50718   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
50719   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
50720
50721   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
50722   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
50723   if (!arg2) {
50724     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
50725     return 0;
50726   }
50727   {
50728     try {
50729       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
50730     } CALL_CATCH_EXCEPTION(0);
50731   }
50732
50733   jresult = (void *)result;
50734   return jresult;
50735 }
50736
50737
50738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
50739   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
50740
50741   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
50742   {
50743     try {
50744       delete arg1;
50745     } CALL_CATCH_EXCEPTION();
50746   }
50747
50748 }
50749
50750
50751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
50752   void * jresult ;
50753   Dali::Toolkit::PageFactory *arg1 = 0 ;
50754   Dali::Vector2 *arg2 = 0 ;
50755   Dali::Toolkit::PageTurnPortraitView result;
50756
50757   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
50758   if (!arg1) {
50759     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
50760     return 0;
50761   }
50762   arg2 = (Dali::Vector2 *)jarg2;
50763   if (!arg2) {
50764     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
50765     return 0;
50766   }
50767   {
50768     try {
50769       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
50770     } CALL_CATCH_EXCEPTION(0);
50771   }
50772
50773   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
50774   return jresult;
50775 }
50776
50777
50778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
50779   void * jresult ;
50780   Dali::BaseHandle arg1 ;
50781   Dali::BaseHandle *argp1 ;
50782   Dali::Toolkit::PageTurnPortraitView result;
50783
50784   argp1 = (Dali::BaseHandle *)jarg1;
50785   if (!argp1) {
50786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
50787     return 0;
50788   }
50789   arg1 = *argp1;
50790   {
50791     try {
50792       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
50793     } CALL_CATCH_EXCEPTION(0);
50794   }
50795
50796   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
50797   return jresult;
50798 }
50799
50800
50801 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
50802   int jresult ;
50803   int result;
50804
50805   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
50806   jresult = (int)result;
50807   return jresult;
50808 }
50809
50810
50811 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
50812   int jresult ;
50813   int result;
50814
50815   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
50816   jresult = (int)result;
50817   return jresult;
50818 }
50819
50820
50821 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
50822   int jresult ;
50823   int result;
50824
50825   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
50826   jresult = (int)result;
50827   return jresult;
50828 }
50829
50830
50831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
50832   void * jresult ;
50833   Dali::Toolkit::ToggleButton::Property *result = 0 ;
50834
50835   {
50836     try {
50837       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
50838     } CALL_CATCH_EXCEPTION(0);
50839   }
50840
50841   jresult = (void *)result;
50842   return jresult;
50843 }
50844
50845
50846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
50847   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
50848
50849   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
50850   {
50851     try {
50852       delete arg1;
50853     } CALL_CATCH_EXCEPTION();
50854   }
50855
50856 }
50857
50858
50859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
50860   void * jresult ;
50861   Dali::Toolkit::ToggleButton *result = 0 ;
50862
50863   {
50864     try {
50865       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
50866     } CALL_CATCH_EXCEPTION(0);
50867   }
50868
50869   jresult = (void *)result;
50870   return jresult;
50871 }
50872
50873
50874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
50875   void * jresult ;
50876   Dali::Toolkit::ToggleButton *arg1 = 0 ;
50877   Dali::Toolkit::ToggleButton *result = 0 ;
50878
50879   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
50880   if (!arg1) {
50881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
50882     return 0;
50883   }
50884   {
50885     try {
50886       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
50887     } CALL_CATCH_EXCEPTION(0);
50888   }
50889
50890   jresult = (void *)result;
50891   return jresult;
50892 }
50893
50894
50895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
50896   void * jresult ;
50897   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
50898   Dali::Toolkit::ToggleButton *arg2 = 0 ;
50899   Dali::Toolkit::ToggleButton *result = 0 ;
50900
50901   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
50902   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
50903   if (!arg2) {
50904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
50905     return 0;
50906   }
50907   {
50908     try {
50909       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
50910     } CALL_CATCH_EXCEPTION(0);
50911   }
50912
50913   jresult = (void *)result;
50914   return jresult;
50915 }
50916
50917
50918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
50919   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
50920
50921   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
50922   {
50923     try {
50924       delete arg1;
50925     } CALL_CATCH_EXCEPTION();
50926   }
50927
50928 }
50929
50930
50931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
50932   void * jresult ;
50933   Dali::Toolkit::ToggleButton result;
50934
50935   {
50936     try {
50937       result = Dali::Toolkit::ToggleButton::New();
50938     } CALL_CATCH_EXCEPTION(0);
50939   }
50940
50941   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
50942   return jresult;
50943 }
50944
50945
50946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
50947   void * jresult ;
50948   Dali::BaseHandle arg1 ;
50949   Dali::BaseHandle *argp1 ;
50950   Dali::Toolkit::ToggleButton result;
50951
50952   argp1 = (Dali::BaseHandle *)jarg1;
50953   if (!argp1) {
50954     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
50955     return 0;
50956   }
50957   arg1 = *argp1;
50958   {
50959     try {
50960       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
50961     } CALL_CATCH_EXCEPTION(0);
50962   }
50963
50964   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
50965   return jresult;
50966 }
50967
50968
50969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
50970   void * jresult ;
50971   Dali::Toolkit::Visual::Base *result = 0 ;
50972
50973   {
50974     try {
50975       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
50976     } CALL_CATCH_EXCEPTION(0);
50977   }
50978
50979   jresult = (void *)result;
50980   return jresult;
50981 }
50982
50983
50984 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
50985   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
50986
50987   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
50988   {
50989     try {
50990       delete arg1;
50991     } CALL_CATCH_EXCEPTION();
50992   }
50993
50994 }
50995
50996
50997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
50998   void * jresult ;
50999   Dali::Toolkit::Visual::Base *arg1 = 0 ;
51000   Dali::Toolkit::Visual::Base *result = 0 ;
51001
51002   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
51003   if (!arg1) {
51004     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
51005     return 0;
51006   }
51007   {
51008     try {
51009       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
51010     } CALL_CATCH_EXCEPTION(0);
51011   }
51012
51013   jresult = (void *)result;
51014   return jresult;
51015 }
51016
51017
51018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
51019   void * jresult ;
51020   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
51021   Dali::Toolkit::Visual::Base *arg2 = 0 ;
51022   Dali::Toolkit::Visual::Base *result = 0 ;
51023
51024   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
51025   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
51026   if (!arg2) {
51027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
51028     return 0;
51029   }
51030   {
51031     try {
51032       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
51033     } CALL_CATCH_EXCEPTION(0);
51034   }
51035
51036   jresult = (void *)result;
51037   return jresult;
51038 }
51039
51040
51041 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
51042   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
51043   std::string *arg2 = 0 ;
51044
51045   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
51046   if (!jarg2) {
51047     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
51048     return ;
51049   }
51050   std::string arg2_str(jarg2);
51051   arg2 = &arg2_str;
51052   {
51053     try {
51054       (arg1)->SetName((std::string const &)*arg2);
51055     } CALL_CATCH_EXCEPTION();
51056   }
51057
51058
51059   //argout typemap for const std::string&
51060
51061 }
51062
51063
51064 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
51065   char * jresult ;
51066   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
51067   std::string *result = 0 ;
51068
51069   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
51070   {
51071     try {
51072       result = (std::string *) &(arg1)->GetName();
51073     } CALL_CATCH_EXCEPTION(0);
51074   }
51075
51076   jresult = SWIG_csharp_string_callback(result->c_str());
51077   return jresult;
51078 }
51079
51080
51081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
51082   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
51083   Dali::Property::Map *arg2 = 0 ;
51084   Dali::Size arg3 ;
51085   Dali::Size *argp3 ;
51086
51087   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
51088   arg2 = (Dali::Property::Map *)jarg2;
51089   if (!arg2) {
51090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
51091     return ;
51092   }
51093   argp3 = (Dali::Size *)jarg3;
51094   if (!argp3) {
51095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
51096     return ;
51097   }
51098   arg3 = *argp3;
51099   {
51100     try {
51101       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
51102     } CALL_CATCH_EXCEPTION();
51103   }
51104
51105 }
51106
51107
51108 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
51109   float jresult ;
51110   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
51111   float arg2 ;
51112   float result;
51113
51114   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
51115   arg2 = (float)jarg2;
51116   {
51117     try {
51118       result = (float)(arg1)->GetHeightForWidth(arg2);
51119     } CALL_CATCH_EXCEPTION(0);
51120   }
51121
51122   jresult = result;
51123   return jresult;
51124 }
51125
51126
51127 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
51128   float jresult ;
51129   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
51130   float arg2 ;
51131   float result;
51132
51133   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
51134   arg2 = (float)jarg2;
51135   {
51136     try {
51137       result = (float)(arg1)->GetWidthForHeight(arg2);
51138     } CALL_CATCH_EXCEPTION(0);
51139   }
51140
51141   jresult = result;
51142   return jresult;
51143 }
51144
51145
51146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
51147   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
51148   Dali::Vector2 *arg2 = 0 ;
51149
51150   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
51151   arg2 = (Dali::Vector2 *)jarg2;
51152   if (!arg2) {
51153     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
51154     return ;
51155   }
51156   {
51157     try {
51158       (arg1)->GetNaturalSize(*arg2);
51159     } CALL_CATCH_EXCEPTION();
51160   }
51161
51162 }
51163
51164
51165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, int jarg2) {
51166   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
51167   float arg2 ;
51168
51169   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
51170   arg2 = (int)jarg2;
51171   {
51172     try {
51173       (arg1)->SetDepthIndex(arg2);
51174     } CALL_CATCH_EXCEPTION();
51175   }
51176
51177 }
51178
51179
51180 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
51181   int jresult ;
51182   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
51183   int result;
51184
51185   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
51186   {
51187     try {
51188       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
51189     } CALL_CATCH_EXCEPTION(0);
51190   }
51191
51192   jresult = result;
51193   return jresult;
51194 }
51195
51196
51197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
51198   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
51199   Dali::Property::Map *arg2 = 0 ;
51200
51201   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
51202   arg2 = (Dali::Property::Map *)jarg2;
51203   if (!arg2) {
51204     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
51205     return ;
51206   }
51207   {
51208     try {
51209       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
51210     } CALL_CATCH_EXCEPTION();
51211   }
51212
51213 }
51214
51215
51216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
51217   void * jresult ;
51218   Dali::Toolkit::VisualFactory result;
51219
51220   {
51221     try {
51222       result = Dali::Toolkit::VisualFactory::Get();
51223     } CALL_CATCH_EXCEPTION(0);
51224   }
51225
51226   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
51227   return jresult;
51228 }
51229
51230
51231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
51232   void * jresult ;
51233   Dali::Toolkit::VisualFactory *result = 0 ;
51234
51235   {
51236     try {
51237       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
51238     } CALL_CATCH_EXCEPTION(0);
51239   }
51240
51241   jresult = (void *)result;
51242   return jresult;
51243 }
51244
51245
51246 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
51247   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
51248
51249   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
51250   {
51251     try {
51252       delete arg1;
51253     } CALL_CATCH_EXCEPTION();
51254   }
51255
51256 }
51257
51258
51259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
51260   void * jresult ;
51261   Dali::Toolkit::VisualFactory *arg1 = 0 ;
51262   Dali::Toolkit::VisualFactory *result = 0 ;
51263
51264   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
51265   if (!arg1) {
51266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
51267     return 0;
51268   }
51269   {
51270     try {
51271       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
51272     } CALL_CATCH_EXCEPTION(0);
51273   }
51274
51275   jresult = (void *)result;
51276   return jresult;
51277 }
51278
51279
51280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
51281   void * jresult ;
51282   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
51283   Dali::Toolkit::VisualFactory *arg2 = 0 ;
51284   Dali::Toolkit::VisualFactory *result = 0 ;
51285
51286   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
51287   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
51288   if (!arg2) {
51289     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
51290     return 0;
51291   }
51292   {
51293     try {
51294       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
51295     } CALL_CATCH_EXCEPTION(0);
51296   }
51297
51298   jresult = (void *)result;
51299   return jresult;
51300 }
51301
51302
51303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
51304   void * jresult ;
51305   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
51306   Dali::Property::Map *arg2 = 0 ;
51307   Dali::Toolkit::Visual::Base result;
51308
51309   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
51310   arg2 = (Dali::Property::Map *)jarg2;
51311   if (!arg2) {
51312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
51313     return 0;
51314   }
51315   {
51316     try {
51317       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
51318     } CALL_CATCH_EXCEPTION(0);
51319   }
51320
51321   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
51322   return jresult;
51323 }
51324
51325
51326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
51327   void * jresult ;
51328   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
51329   std::string *arg2 = 0 ;
51330   Dali::ImageDimensions arg3 ;
51331   Dali::ImageDimensions *argp3 ;
51332   Dali::Toolkit::Visual::Base result;
51333
51334   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
51335   if (!jarg2) {
51336     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
51337     return 0;
51338   }
51339   std::string arg2_str(jarg2);
51340   arg2 = &arg2_str;
51341   argp3 = (Dali::ImageDimensions *)jarg3;
51342   if (!argp3) {
51343     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
51344     return 0;
51345   }
51346   arg3 = *argp3;
51347   {
51348     try {
51349       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
51350     } CALL_CATCH_EXCEPTION(0);
51351   }
51352
51353   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
51354
51355   //argout typemap for const std::string&
51356
51357   return jresult;
51358 }
51359
51360
51361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
51362   void * jresult ;
51363   Dali::Toolkit::AsyncImageLoader *result = 0 ;
51364
51365   {
51366     try {
51367       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
51368     } CALL_CATCH_EXCEPTION(0);
51369   }
51370
51371   jresult = (void *)result;
51372   return jresult;
51373 }
51374
51375
51376 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
51377   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
51378
51379   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
51380   {
51381     try {
51382       delete arg1;
51383     } CALL_CATCH_EXCEPTION();
51384   }
51385
51386 }
51387
51388
51389 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
51390   void * jresult ;
51391   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
51392   Dali::Toolkit::AsyncImageLoader *result = 0 ;
51393
51394   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
51395   if (!arg1) {
51396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
51397     return 0;
51398   }
51399   {
51400     try {
51401       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
51402     } CALL_CATCH_EXCEPTION(0);
51403   }
51404
51405   jresult = (void *)result;
51406   return jresult;
51407 }
51408
51409
51410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
51411   void * jresult ;
51412   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
51413   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
51414   Dali::Toolkit::AsyncImageLoader *result = 0 ;
51415
51416   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
51417   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
51418   if (!arg2) {
51419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
51420     return 0;
51421   }
51422   {
51423     try {
51424       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
51425     } CALL_CATCH_EXCEPTION(0);
51426   }
51427
51428   jresult = (void *)result;
51429   return jresult;
51430 }
51431
51432
51433 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
51434   void * jresult ;
51435   Dali::Toolkit::AsyncImageLoader result;
51436
51437   {
51438     try {
51439       result = Dali::Toolkit::AsyncImageLoader::New();
51440     } CALL_CATCH_EXCEPTION(0);
51441   }
51442
51443   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
51444   return jresult;
51445 }
51446
51447
51448 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
51449   void * jresult ;
51450   Dali::BaseHandle arg1 ;
51451   Dali::BaseHandle *argp1 ;
51452   Dali::Toolkit::AsyncImageLoader result;
51453
51454   argp1 = (Dali::BaseHandle *)jarg1;
51455   if (!argp1) {
51456     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
51457     return 0;
51458   }
51459   arg1 = *argp1;
51460   {
51461     try {
51462       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
51463     } CALL_CATCH_EXCEPTION(0);
51464   }
51465
51466   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
51467   return jresult;
51468 }
51469
51470
51471 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
51472   unsigned int jresult ;
51473   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
51474   std::string *arg2 = 0 ;
51475   uint32_t result;
51476
51477   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
51478   if (!jarg2) {
51479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
51480     return 0;
51481   }
51482   std::string arg2_str(jarg2);
51483   arg2 = &arg2_str;
51484   {
51485     try {
51486       result = (arg1)->Load((std::string const &)*arg2);
51487     } CALL_CATCH_EXCEPTION(0);
51488   }
51489
51490   jresult = result;
51491
51492   //argout typemap for const std::string&
51493
51494   return jresult;
51495 }
51496
51497
51498 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
51499   unsigned int jresult ;
51500   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
51501   std::string *arg2 = 0 ;
51502   Dali::ImageDimensions arg3 ;
51503   Dali::ImageDimensions *argp3 ;
51504   uint32_t result;
51505
51506   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
51507   if (!jarg2) {
51508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
51509     return 0;
51510   }
51511   std::string arg2_str(jarg2);
51512   arg2 = &arg2_str;
51513   argp3 = (Dali::ImageDimensions *)jarg3;
51514   if (!argp3) {
51515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
51516     return 0;
51517   }
51518   arg3 = *argp3;
51519   {
51520     try {
51521       result = (arg1)->Load((std::string const &)*arg2,arg3);
51522     } CALL_CATCH_EXCEPTION(0);
51523   }
51524
51525   jresult = result;
51526
51527   //argout typemap for const std::string&
51528
51529   return jresult;
51530 }
51531
51532
51533 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
51534   unsigned int jresult ;
51535   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
51536   std::string *arg2 = 0 ;
51537   Dali::ImageDimensions arg3 ;
51538   Dali::FittingMode::Type arg4 ;
51539   Dali::SamplingMode::Type arg5 ;
51540   bool arg6 ;
51541   Dali::ImageDimensions *argp3 ;
51542   uint32_t result;
51543
51544   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
51545   if (!jarg2) {
51546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
51547     return 0;
51548   }
51549   std::string arg2_str(jarg2);
51550   arg2 = &arg2_str;
51551   argp3 = (Dali::ImageDimensions *)jarg3;
51552   if (!argp3) {
51553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
51554     return 0;
51555   }
51556   arg3 = *argp3;
51557   arg4 = (Dali::FittingMode::Type)jarg4;
51558   arg5 = (Dali::SamplingMode::Type)jarg5;
51559   arg6 = jarg6 ? true : false;
51560   {
51561     try {
51562       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
51563     } CALL_CATCH_EXCEPTION(0);
51564   }
51565
51566   jresult = result;
51567
51568   //argout typemap for const std::string&
51569
51570   return jresult;
51571 }
51572
51573
51574 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
51575   unsigned int jresult ;
51576   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
51577   uint32_t arg2 ;
51578   bool result;
51579
51580   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
51581   arg2 = (uint32_t)jarg2;
51582   {
51583     try {
51584       result = (bool)(arg1)->Cancel(arg2);
51585     } CALL_CATCH_EXCEPTION(0);
51586   }
51587
51588   jresult = result;
51589   return jresult;
51590 }
51591
51592
51593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
51594   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
51595
51596   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
51597   {
51598     try {
51599       (arg1)->CancelAll();
51600     } CALL_CATCH_EXCEPTION();
51601   }
51602
51603 }
51604
51605
51606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
51607   void * jresult ;
51608   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
51609   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
51610
51611   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
51612   {
51613     try {
51614       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
51615     } CALL_CATCH_EXCEPTION(0);
51616   }
51617
51618   jresult = (void *)result;
51619   return jresult;
51620 }
51621
51622
51623 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
51624   void * jresult ;
51625   std::string *arg1 = 0 ;
51626   Dali::PixelData result;
51627
51628   if (!jarg1) {
51629     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
51630     return 0;
51631   }
51632   std::string arg1_str(jarg1);
51633   arg1 = &arg1_str;
51634   {
51635     try {
51636       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
51637     } CALL_CATCH_EXCEPTION(0);
51638   }
51639
51640   jresult = new Dali::PixelData((const Dali::PixelData &)result);
51641
51642   //argout typemap for const std::string&
51643
51644   return jresult;
51645 }
51646
51647
51648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
51649   void * jresult ;
51650   std::string *arg1 = 0 ;
51651   Dali::ImageDimensions arg2 ;
51652   Dali::ImageDimensions *argp2 ;
51653   Dali::PixelData result;
51654
51655   if (!jarg1) {
51656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
51657     return 0;
51658   }
51659   std::string arg1_str(jarg1);
51660   arg1 = &arg1_str;
51661   argp2 = (Dali::ImageDimensions *)jarg2;
51662   if (!argp2) {
51663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
51664     return 0;
51665   }
51666   arg2 = *argp2;
51667   {
51668     try {
51669       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
51670     } CALL_CATCH_EXCEPTION(0);
51671   }
51672
51673   jresult = new Dali::PixelData((const Dali::PixelData &)result);
51674
51675   //argout typemap for const std::string&
51676
51677   return jresult;
51678 }
51679
51680
51681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
51682   void * jresult ;
51683   std::string *arg1 = 0 ;
51684   Dali::ImageDimensions arg2 ;
51685   Dali::FittingMode::Type arg3 ;
51686   Dali::SamplingMode::Type arg4 ;
51687   bool arg5 ;
51688   Dali::ImageDimensions *argp2 ;
51689   Dali::PixelData result;
51690
51691   if (!jarg1) {
51692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
51693     return 0;
51694   }
51695   std::string arg1_str(jarg1);
51696   arg1 = &arg1_str;
51697   argp2 = (Dali::ImageDimensions *)jarg2;
51698   if (!argp2) {
51699     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
51700     return 0;
51701   }
51702   arg2 = *argp2;
51703   arg3 = (Dali::FittingMode::Type)jarg3;
51704   arg4 = (Dali::SamplingMode::Type)jarg4;
51705   arg5 = jarg5 ? true : false;
51706   {
51707     try {
51708       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
51709     } CALL_CATCH_EXCEPTION(0);
51710   }
51711
51712   jresult = new Dali::PixelData((const Dali::PixelData &)result);
51713
51714   //argout typemap for const std::string&
51715
51716   return jresult;
51717 }
51718
51719
51720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
51721   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
51722
51723   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
51724   {
51725     try {
51726       delete arg1;
51727     } CALL_CATCH_EXCEPTION();
51728   }
51729
51730 }
51731
51732
51733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
51734   void * jresult ;
51735   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
51736   Dali::Actor arg2 ;
51737   Dali::Actor arg3 ;
51738   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
51739   Dali::Actor *argp2 ;
51740   Dali::Actor *argp3 ;
51741   Dali::Actor result;
51742
51743   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
51744   argp2 = (Dali::Actor *)jarg2;
51745   if (!argp2) {
51746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51747     return 0;
51748   }
51749   arg2 = *argp2;
51750   argp3 = (Dali::Actor *)jarg3;
51751   if (!argp3) {
51752     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51753     return 0;
51754   }
51755   arg3 = *argp3;
51756   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
51757   {
51758     try {
51759       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4);
51760     } CALL_CATCH_EXCEPTION(0);
51761   }
51762
51763   jresult = new Dali::Actor((const Dali::Actor &)result);
51764   return jresult;
51765 }
51766
51767
51768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
51769   void * jresult ;
51770   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
51771
51772   {
51773     try {
51774       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
51775     } CALL_CATCH_EXCEPTION(0);
51776   }
51777
51778   jresult = (void *)result;
51779   return jresult;
51780 }
51781
51782
51783 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_director_connect(void *objarg, SwigDirector_FrameCallbackInterface::SWIG_Callback0_t callback0) {
51784   Dali::FrameCallbackInterface *obj = (Dali::FrameCallbackInterface *)objarg;
51785   SwigDirector_FrameCallbackInterface *director = dynamic_cast<SwigDirector_FrameCallbackInterface *>(obj);
51786   if (director) {
51787     director->swig_connect_director(callback0);
51788   }
51789 }
51790
51791
51792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameCallbackInterface() {
51793   void * jresult ;
51794   Dali::FrameCallbackInterface *result = 0 ;
51795
51796   {
51797     try {
51798       result =(Dali::FrameCallbackInterface *) new SwigDirector_FrameCallbackInterface();
51799     } CALL_CATCH_EXCEPTION(0);
51800   }
51801
51802   jresult = (void *)result;
51803   return jresult;
51804 }
51805
51806 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetPosition(void * updateProxy, unsigned int id,  void* position) {
51807   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
51808   Dali::Vector3* vector3 = (Dali::Vector3 *)position;
51809   return proxy->GetPosition(id, *vector3);
51810 }
51811
51812 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetPosition(void * updateProxy, unsigned int id, void* position) {
51813   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
51814   Dali::Vector3* vector3 = (Dali::Vector3 *)position;
51815   return proxy->SetPosition(id, *vector3);
51816 }
51817
51818 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakePosition(void * updateProxy, unsigned int id, void* position) {
51819   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
51820   Dali::Vector3* vector3 = (Dali::Vector3 *)position;
51821   return proxy->BakePosition(id, *vector3);
51822 }
51823
51824 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetSize(void * updateProxy, unsigned int id, void* size) {
51825   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
51826   Dali::Vector3* vector3 = (Dali::Vector3 *)size;
51827   return proxy->GetSize(id, *vector3);
51828 }
51829
51830 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetSize(void * updateProxy, unsigned int id, void* size) {
51831   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
51832   Dali::Vector3* vector3 = (Dali::Vector3 *)size;
51833   return proxy->SetSize(id, *vector3);
51834 }
51835 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakeSize(void * updateProxy, unsigned int id, void* size) {
51836   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
51837   Dali::Vector3* vector3 = (Dali::Vector3 *)size;
51838   return proxy->BakeSize(id, *vector3);
51839 }
51840
51841 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetPositionAndSize(void * updateProxy, unsigned int id, void* position, void* size) {
51842   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
51843   Dali::Vector3* vector3_pos = (Dali::Vector3 *)position;
51844   Dali::Vector3* vector3_size = (Dali::Vector3 *)size;
51845   return proxy->GetPositionAndSize(id, *vector3_pos, *vector3_size);
51846 }
51847
51848 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetScale(void * updateProxy, unsigned int id, void* scale) {
51849   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
51850   Dali::Vector3* vector3 = (Dali::Vector3 *)scale;
51851   return proxy->GetScale(id,* vector3);
51852 }
51853
51854 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetScale(void * updateProxy, unsigned int id, void* scale) {
51855   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
51856   Dali::Vector3* vector3 = (Dali::Vector3 *)scale;
51857   return proxy->SetScale(id, *vector3);
51858 }
51859
51860 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakeScale(void * updateProxy, unsigned int id, void* scale) {
51861   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
51862   Dali::Vector3* vector3 = (Dali::Vector3 *)scale;
51863   return proxy->BakeScale(id, *vector3);
51864 }
51865
51866 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetColor(void * updateProxy, unsigned int id, void* color) {
51867   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
51868   Dali::Vector4* vector4 = (Dali::Vector4 *)color;
51869   return proxy->GetColor(id, *vector4);
51870 }
51871
51872 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetColor(void * updateProxy, unsigned int id, void* color) {
51873   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
51874   Dali::Vector4* vector4 = (Dali::Vector4 *)color;
51875   return proxy->SetColor(id, *vector4);
51876 }
51877
51878 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakeColor(void * updateProxy, unsigned int id, void* color) {
51879   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
51880   Dali::Vector4* vector4 = (Dali::Vector4 *)color;
51881   return proxy->BakeColor(id, *vector4);
51882 }
51883
51884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_AddFrameCallback(void * jarg1, void* jarg2, void* jarg3) {
51885   Dali::FrameCallbackInterface *obj = (Dali::FrameCallbackInterface *)jarg2;
51886   SwigDirector_FrameCallbackInterface *arg2 = dynamic_cast<SwigDirector_FrameCallbackInterface *>(obj);
51887
51888   Dali::Stage *arg1 = (Dali::Stage *) 0;
51889   Dali::Actor *arg3 = 0;
51890
51891   arg1 = (Dali::Stage *)jarg1;
51892   arg3 = (Dali::Actor *)jarg3;
51893
51894   DevelStage::AddFrameCallback( *arg1, *arg2, *arg3 );
51895   return;
51896 }
51897
51898 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_RemoveFrameCallback(void * jarg1, void* jarg2) {
51899
51900   Dali::FrameCallbackInterface *obj = (Dali::FrameCallbackInterface *)jarg2;
51901   SwigDirector_FrameCallbackInterface *arg2 = dynamic_cast<SwigDirector_FrameCallbackInterface *>(obj);
51902
51903   Dali::Stage *arg1 = (Dali::Stage *) 0;
51904
51905   arg1 = (Dali::Stage *)jarg1;
51906
51907   DevelStage::RemoveFrameCallback( *arg1, *arg2 );
51908   return;
51909 }
51910
51911 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
51912   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
51913   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
51914   if (director) {
51915     director->swig_connect_director(callback0);
51916   }
51917 }
51918
51919 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
51920   KeyboardFocusManager arg1 ;
51921   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
51922   KeyboardFocusManager *argp1 ;
51923
51924   argp1 = (KeyboardFocusManager *)jarg1;
51925   if (!argp1) {
51926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
51927     return ;
51928   }
51929   arg1 = *argp1;
51930   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
51931   //Null checking of arg2 is removed. arg2's null set means resetting so it can be a null value.
51932   {
51933     try {
51934       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
51935     } CALL_CATCH_EXCEPTION();
51936   }
51937
51938 }
51939
51940
51941 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
51942   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
51943
51944   arg1 = (std::vector< unsigned int > *)jarg1;
51945   {
51946     try {
51947       (arg1)->clear();
51948     } CALL_CATCH_EXCEPTION();
51949   }
51950
51951 }
51952
51953
51954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
51955   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
51956   unsigned int *arg2 = 0 ;
51957   unsigned int temp2 ;
51958
51959   arg1 = (std::vector< unsigned int > *)jarg1;
51960   temp2 = (unsigned int)jarg2;
51961   arg2 = &temp2;
51962   {
51963     try {
51964       (arg1)->push_back((unsigned int const &)*arg2);
51965     } CALL_CATCH_EXCEPTION();
51966   }
51967
51968 }
51969
51970
51971 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
51972   unsigned long jresult ;
51973   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
51974   std::vector< unsigned int >::size_type result;
51975
51976   arg1 = (std::vector< unsigned int > *)jarg1;
51977   {
51978     try {
51979       result = ((std::vector< unsigned int > const *)arg1)->size();
51980     } CALL_CATCH_EXCEPTION(0);
51981   }
51982
51983   jresult = (unsigned long)result;
51984   return jresult;
51985 }
51986
51987
51988 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
51989   unsigned long jresult ;
51990   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
51991   std::vector< unsigned int >::size_type result;
51992
51993   arg1 = (std::vector< unsigned int > *)jarg1;
51994   {
51995     try {
51996       result = ((std::vector< unsigned int > const *)arg1)->capacity();
51997     } CALL_CATCH_EXCEPTION(0);
51998   }
51999
52000   jresult = (unsigned long)result;
52001   return jresult;
52002 }
52003
52004
52005 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
52006   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52007   std::vector< unsigned int >::size_type arg2 ;
52008
52009   arg1 = (std::vector< unsigned int > *)jarg1;
52010   arg2 = (std::vector< unsigned int >::size_type)jarg2;
52011   {
52012     try {
52013       (arg1)->reserve(arg2);
52014     } CALL_CATCH_EXCEPTION();
52015   }
52016
52017 }
52018
52019
52020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
52021   void * jresult ;
52022   std::vector< unsigned int > *result = 0 ;
52023
52024   {
52025     try {
52026       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
52027     } CALL_CATCH_EXCEPTION(0);
52028   }
52029
52030   jresult = (void *)result;
52031   return jresult;
52032 }
52033
52034
52035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
52036   void * jresult ;
52037   std::vector< unsigned int > *arg1 = 0 ;
52038   std::vector< unsigned int > *result = 0 ;
52039
52040   arg1 = (std::vector< unsigned int > *)jarg1;
52041   if (!arg1) {
52042     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
52043     return 0;
52044   }
52045   {
52046     try {
52047       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
52048     } CALL_CATCH_EXCEPTION(0);
52049   }
52050
52051   jresult = (void *)result;
52052   return jresult;
52053 }
52054
52055
52056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
52057   void * jresult ;
52058   int arg1 ;
52059   std::vector< unsigned int > *result = 0 ;
52060
52061   arg1 = (int)jarg1;
52062   {
52063     try {
52064       try {
52065         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
52066       }
52067       catch(std::out_of_range &_e) {
52068         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52069         return 0;
52070       }
52071
52072     } CALL_CATCH_EXCEPTION(0);
52073   }
52074
52075   jresult = (void *)result;
52076   return jresult;
52077 }
52078
52079
52080 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
52081   unsigned int jresult ;
52082   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52083   int arg2 ;
52084   unsigned int result;
52085
52086   arg1 = (std::vector< unsigned int > *)jarg1;
52087   arg2 = (int)jarg2;
52088   {
52089     try {
52090       try {
52091         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
52092       }
52093       catch(std::out_of_range &_e) {
52094         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52095         return 0;
52096       }
52097
52098     } CALL_CATCH_EXCEPTION(0);
52099   }
52100
52101   jresult = result;
52102   return jresult;
52103 }
52104
52105
52106 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
52107   unsigned int jresult ;
52108   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52109   int arg2 ;
52110   unsigned int *result = 0 ;
52111
52112   arg1 = (std::vector< unsigned int > *)jarg1;
52113   arg2 = (int)jarg2;
52114   {
52115     try {
52116       try {
52117         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
52118       }
52119       catch(std::out_of_range &_e) {
52120         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52121         return 0;
52122       }
52123
52124     } CALL_CATCH_EXCEPTION(0);
52125   }
52126
52127   jresult = *result;
52128   return jresult;
52129 }
52130
52131
52132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
52133   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52134   int arg2 ;
52135   unsigned int *arg3 = 0 ;
52136   unsigned int temp3 ;
52137
52138   arg1 = (std::vector< unsigned int > *)jarg1;
52139   arg2 = (int)jarg2;
52140   temp3 = (unsigned int)jarg3;
52141   arg3 = &temp3;
52142   {
52143     try {
52144       try {
52145         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
52146       }
52147       catch(std::out_of_range &_e) {
52148         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52149         return ;
52150       }
52151
52152     } CALL_CATCH_EXCEPTION();
52153   }
52154
52155 }
52156
52157
52158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
52159   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52160   std::vector< unsigned int > *arg2 = 0 ;
52161
52162   arg1 = (std::vector< unsigned int > *)jarg1;
52163   arg2 = (std::vector< unsigned int > *)jarg2;
52164   if (!arg2) {
52165     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
52166     return ;
52167   }
52168   {
52169     try {
52170       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
52171     } CALL_CATCH_EXCEPTION();
52172   }
52173
52174 }
52175
52176
52177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
52178   void * jresult ;
52179   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52180   int arg2 ;
52181   int arg3 ;
52182   std::vector< unsigned int > *result = 0 ;
52183
52184   arg1 = (std::vector< unsigned int > *)jarg1;
52185   arg2 = (int)jarg2;
52186   arg3 = (int)jarg3;
52187   {
52188     try {
52189       try {
52190         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
52191       }
52192       catch(std::out_of_range &_e) {
52193         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52194         return 0;
52195       }
52196       catch(std::invalid_argument &_e) {
52197         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
52198         return 0;
52199       }
52200
52201     } CALL_CATCH_EXCEPTION(0);
52202   }
52203
52204   jresult = (void *)result;
52205   return jresult;
52206 }
52207
52208
52209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
52210   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52211   int arg2 ;
52212   unsigned int *arg3 = 0 ;
52213   unsigned int temp3 ;
52214
52215   arg1 = (std::vector< unsigned int > *)jarg1;
52216   arg2 = (int)jarg2;
52217   temp3 = (unsigned int)jarg3;
52218   arg3 = &temp3;
52219   {
52220     try {
52221       try {
52222         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
52223       }
52224       catch(std::out_of_range &_e) {
52225         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52226         return ;
52227       }
52228
52229     } CALL_CATCH_EXCEPTION();
52230   }
52231
52232 }
52233
52234
52235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
52236   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52237   int arg2 ;
52238   std::vector< unsigned int > *arg3 = 0 ;
52239
52240   arg1 = (std::vector< unsigned int > *)jarg1;
52241   arg2 = (int)jarg2;
52242   arg3 = (std::vector< unsigned int > *)jarg3;
52243   if (!arg3) {
52244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
52245     return ;
52246   }
52247   {
52248     try {
52249       try {
52250         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
52251       }
52252       catch(std::out_of_range &_e) {
52253         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52254         return ;
52255       }
52256
52257     } CALL_CATCH_EXCEPTION();
52258   }
52259
52260 }
52261
52262
52263 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
52264   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52265   int arg2 ;
52266
52267   arg1 = (std::vector< unsigned int > *)jarg1;
52268   arg2 = (int)jarg2;
52269   {
52270     try {
52271       try {
52272         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
52273       }
52274       catch(std::out_of_range &_e) {
52275         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52276         return ;
52277       }
52278
52279     } CALL_CATCH_EXCEPTION();
52280   }
52281
52282 }
52283
52284
52285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
52286   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52287   int arg2 ;
52288   int arg3 ;
52289
52290   arg1 = (std::vector< unsigned int > *)jarg1;
52291   arg2 = (int)jarg2;
52292   arg3 = (int)jarg3;
52293   {
52294     try {
52295       try {
52296         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
52297       }
52298       catch(std::out_of_range &_e) {
52299         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52300         return ;
52301       }
52302       catch(std::invalid_argument &_e) {
52303         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
52304         return ;
52305       }
52306
52307     } CALL_CATCH_EXCEPTION();
52308   }
52309
52310 }
52311
52312
52313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
52314   void * jresult ;
52315   unsigned int *arg1 = 0 ;
52316   int arg2 ;
52317   unsigned int temp1 ;
52318   std::vector< unsigned int > *result = 0 ;
52319
52320   temp1 = (unsigned int)jarg1;
52321   arg1 = &temp1;
52322   arg2 = (int)jarg2;
52323   {
52324     try {
52325       try {
52326         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
52327       }
52328       catch(std::out_of_range &_e) {
52329         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52330         return 0;
52331       }
52332
52333     } CALL_CATCH_EXCEPTION(0);
52334   }
52335
52336   jresult = (void *)result;
52337   return jresult;
52338 }
52339
52340
52341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
52342   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52343
52344   arg1 = (std::vector< unsigned int > *)jarg1;
52345   {
52346     try {
52347       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
52348     } CALL_CATCH_EXCEPTION();
52349   }
52350
52351 }
52352
52353
52354 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
52355   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52356   int arg2 ;
52357   int arg3 ;
52358
52359   arg1 = (std::vector< unsigned int > *)jarg1;
52360   arg2 = (int)jarg2;
52361   arg3 = (int)jarg3;
52362   {
52363     try {
52364       try {
52365         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
52366       }
52367       catch(std::out_of_range &_e) {
52368         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52369         return ;
52370       }
52371       catch(std::invalid_argument &_e) {
52372         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
52373         return ;
52374       }
52375
52376     } CALL_CATCH_EXCEPTION();
52377   }
52378
52379 }
52380
52381
52382 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
52383   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52384   int arg2 ;
52385   std::vector< unsigned int > *arg3 = 0 ;
52386
52387   arg1 = (std::vector< unsigned int > *)jarg1;
52388   arg2 = (int)jarg2;
52389   arg3 = (std::vector< unsigned int > *)jarg3;
52390   if (!arg3) {
52391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
52392     return ;
52393   }
52394   {
52395     try {
52396       try {
52397         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
52398       }
52399       catch(std::out_of_range &_e) {
52400         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52401         return ;
52402       }
52403
52404     } CALL_CATCH_EXCEPTION();
52405   }
52406
52407 }
52408
52409
52410 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
52411   unsigned int jresult ;
52412   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52413   unsigned int *arg2 = 0 ;
52414   unsigned int temp2 ;
52415   bool result;
52416
52417   arg1 = (std::vector< unsigned int > *)jarg1;
52418   temp2 = (unsigned int)jarg2;
52419   arg2 = &temp2;
52420   {
52421     try {
52422       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
52423     } CALL_CATCH_EXCEPTION(0);
52424   }
52425
52426   jresult = result;
52427   return jresult;
52428 }
52429
52430
52431 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
52432   int jresult ;
52433   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52434   unsigned int *arg2 = 0 ;
52435   unsigned int temp2 ;
52436   int result;
52437
52438   arg1 = (std::vector< unsigned int > *)jarg1;
52439   temp2 = (unsigned int)jarg2;
52440   arg2 = &temp2;
52441   {
52442     try {
52443       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
52444     } CALL_CATCH_EXCEPTION(0);
52445   }
52446
52447   jresult = result;
52448   return jresult;
52449 }
52450
52451
52452 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
52453   int jresult ;
52454   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52455   unsigned int *arg2 = 0 ;
52456   unsigned int temp2 ;
52457   int result;
52458
52459   arg1 = (std::vector< unsigned int > *)jarg1;
52460   temp2 = (unsigned int)jarg2;
52461   arg2 = &temp2;
52462   {
52463     try {
52464       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
52465     } CALL_CATCH_EXCEPTION(0);
52466   }
52467
52468   jresult = result;
52469   return jresult;
52470 }
52471
52472
52473 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
52474   unsigned int jresult ;
52475   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52476   unsigned int *arg2 = 0 ;
52477   unsigned int temp2 ;
52478   bool result;
52479
52480   arg1 = (std::vector< unsigned int > *)jarg1;
52481   temp2 = (unsigned int)jarg2;
52482   arg2 = &temp2;
52483   {
52484     try {
52485       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
52486     } CALL_CATCH_EXCEPTION(0);
52487   }
52488
52489   jresult = result;
52490   return jresult;
52491 }
52492
52493
52494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
52495   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52496
52497   arg1 = (std::vector< unsigned int > *)jarg1;
52498   {
52499     try {
52500       delete arg1;
52501     } CALL_CATCH_EXCEPTION();
52502   }
52503
52504 }
52505
52506
52507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
52508   void * jresult ;
52509   std::pair< unsigned int,Dali::Actor > *result = 0 ;
52510
52511   {
52512     try {
52513       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
52514     } CALL_CATCH_EXCEPTION(0);
52515   }
52516
52517   jresult = (void *)result;
52518   return jresult;
52519 }
52520
52521
52522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
52523   void * jresult ;
52524   unsigned int arg1 ;
52525   Dali::Actor arg2 ;
52526   Dali::Actor *argp2 ;
52527   std::pair< unsigned int,Dali::Actor > *result = 0 ;
52528
52529   arg1 = (unsigned int)jarg1;
52530   argp2 = (Dali::Actor *)jarg2;
52531   if (!argp2) {
52532     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
52533     return 0;
52534   }
52535   arg2 = *argp2;
52536   {
52537     try {
52538       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
52539     } CALL_CATCH_EXCEPTION(0);
52540   }
52541
52542   jresult = (void *)result;
52543   return jresult;
52544 }
52545
52546
52547 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
52548   void * jresult ;
52549   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
52550   std::pair< unsigned int,Dali::Actor > *result = 0 ;
52551
52552   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
52553   if (!arg1) {
52554     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
52555     return 0;
52556   }
52557   {
52558     try {
52559       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
52560     } CALL_CATCH_EXCEPTION(0);
52561   }
52562
52563   jresult = (void *)result;
52564   return jresult;
52565 }
52566
52567
52568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
52569   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
52570   unsigned int arg2 ;
52571
52572   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
52573   arg2 = (unsigned int)jarg2;
52574   if (arg1) (arg1)->first = arg2;
52575 }
52576
52577
52578 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
52579   unsigned int jresult ;
52580   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
52581   unsigned int result;
52582
52583   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
52584   result = (unsigned int) ((arg1)->first);
52585   jresult = result;
52586   return jresult;
52587 }
52588
52589
52590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
52591   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
52592   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
52593
52594   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
52595   arg2 = (Dali::Actor *)jarg2;
52596   if (arg1) (arg1)->second = *arg2;
52597 }
52598
52599
52600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
52601   void * jresult ;
52602   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
52603   Dali::Actor *result = 0 ;
52604
52605   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
52606   result = (Dali::Actor *)& ((arg1)->second);
52607   jresult = (void *)result;
52608   return jresult;
52609 }
52610
52611
52612 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
52613   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
52614
52615   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
52616   {
52617     try {
52618       delete arg1;
52619     } CALL_CATCH_EXCEPTION();
52620   }
52621
52622 }
52623
52624
52625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
52626   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
52627
52628   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52629   {
52630     try {
52631       (arg1)->clear();
52632     } CALL_CATCH_EXCEPTION();
52633   }
52634
52635 }
52636
52637
52638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
52639   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
52640   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
52641
52642   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52643   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
52644   if (!arg2) {
52645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
52646     return ;
52647   }
52648   {
52649     try {
52650       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
52651     } CALL_CATCH_EXCEPTION();
52652   }
52653
52654 }
52655
52656
52657 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
52658   unsigned long jresult ;
52659   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
52660   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
52661
52662   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52663   {
52664     try {
52665       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
52666     } CALL_CATCH_EXCEPTION(0);
52667   }
52668
52669   jresult = (unsigned long)result;
52670   return jresult;
52671 }
52672
52673
52674 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
52675   unsigned long jresult ;
52676   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
52677   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
52678
52679   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52680   {
52681     try {
52682       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
52683     } CALL_CATCH_EXCEPTION(0);
52684   }
52685
52686   jresult = (unsigned long)result;
52687   return jresult;
52688 }
52689
52690
52691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
52692   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
52693   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
52694
52695   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52696   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
52697   {
52698     try {
52699       (arg1)->reserve(arg2);
52700     } CALL_CATCH_EXCEPTION();
52701   }
52702
52703 }
52704
52705
52706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
52707   void * jresult ;
52708   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
52709
52710   {
52711     try {
52712       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
52713     } CALL_CATCH_EXCEPTION(0);
52714   }
52715
52716   jresult = (void *)result;
52717   return jresult;
52718 }
52719
52720
52721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
52722   void * jresult ;
52723   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
52724   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
52725
52726   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52727   if (!arg1) {
52728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
52729     return 0;
52730   }
52731   {
52732     try {
52733       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);
52734     } CALL_CATCH_EXCEPTION(0);
52735   }
52736
52737   jresult = (void *)result;
52738   return jresult;
52739 }
52740
52741
52742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
52743   void * jresult ;
52744   int arg1 ;
52745   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
52746
52747   arg1 = (int)jarg1;
52748   {
52749     try {
52750       try {
52751         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);
52752       }
52753       catch(std::out_of_range &_e) {
52754         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52755         return 0;
52756       }
52757
52758     } CALL_CATCH_EXCEPTION(0);
52759   }
52760
52761   jresult = (void *)result;
52762   return jresult;
52763 }
52764
52765
52766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
52767   void * jresult ;
52768   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
52769   int arg2 ;
52770   std::pair< unsigned int,Dali::Actor > result;
52771
52772   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52773   arg2 = (int)jarg2;
52774   {
52775     try {
52776       try {
52777         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
52778       }
52779       catch(std::out_of_range &_e) {
52780         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52781         return 0;
52782       }
52783
52784     } CALL_CATCH_EXCEPTION(0);
52785   }
52786
52787   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
52788   return jresult;
52789 }
52790
52791
52792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
52793   void * jresult ;
52794   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
52795   int arg2 ;
52796   std::pair< unsigned int,Dali::Actor > *result = 0 ;
52797
52798   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52799   arg2 = (int)jarg2;
52800   {
52801     try {
52802       try {
52803         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
52804       }
52805       catch(std::out_of_range &_e) {
52806         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52807         return 0;
52808       }
52809
52810     } CALL_CATCH_EXCEPTION(0);
52811   }
52812
52813   jresult = (void *)result;
52814   return jresult;
52815 }
52816
52817
52818 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
52819   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
52820   int arg2 ;
52821   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
52822
52823   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52824   arg2 = (int)jarg2;
52825   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
52826   if (!arg3) {
52827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
52828     return ;
52829   }
52830   {
52831     try {
52832       try {
52833         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);
52834       }
52835       catch(std::out_of_range &_e) {
52836         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52837         return ;
52838       }
52839
52840     } CALL_CATCH_EXCEPTION();
52841   }
52842
52843 }
52844
52845
52846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
52847   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
52848   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
52849
52850   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52851   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
52852   if (!arg2) {
52853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
52854     return ;
52855   }
52856   {
52857     try {
52858       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);
52859     } CALL_CATCH_EXCEPTION();
52860   }
52861
52862 }
52863
52864
52865 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
52866   void * jresult ;
52867   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
52868   int arg2 ;
52869   int arg3 ;
52870   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
52871
52872   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52873   arg2 = (int)jarg2;
52874   arg3 = (int)jarg3;
52875   {
52876     try {
52877       try {
52878         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);
52879       }
52880       catch(std::out_of_range &_e) {
52881         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52882         return 0;
52883       }
52884       catch(std::invalid_argument &_e) {
52885         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
52886         return 0;
52887       }
52888
52889     } CALL_CATCH_EXCEPTION(0);
52890   }
52891
52892   jresult = (void *)result;
52893   return jresult;
52894 }
52895
52896
52897 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
52898   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
52899   int arg2 ;
52900   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
52901
52902   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52903   arg2 = (int)jarg2;
52904   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
52905   if (!arg3) {
52906     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
52907     return ;
52908   }
52909   {
52910     try {
52911       try {
52912         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);
52913       }
52914       catch(std::out_of_range &_e) {
52915         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52916         return ;
52917       }
52918
52919     } CALL_CATCH_EXCEPTION();
52920   }
52921
52922 }
52923
52924
52925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
52926   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
52927   int arg2 ;
52928   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
52929
52930   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52931   arg2 = (int)jarg2;
52932   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
52933   if (!arg3) {
52934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
52935     return ;
52936   }
52937   {
52938     try {
52939       try {
52940         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);
52941       }
52942       catch(std::out_of_range &_e) {
52943         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52944         return ;
52945       }
52946
52947     } CALL_CATCH_EXCEPTION();
52948   }
52949
52950 }
52951
52952
52953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
52954   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
52955   int arg2 ;
52956
52957   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52958   arg2 = (int)jarg2;
52959   {
52960     try {
52961       try {
52962         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
52963       }
52964       catch(std::out_of_range &_e) {
52965         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52966         return ;
52967       }
52968
52969     } CALL_CATCH_EXCEPTION();
52970   }
52971
52972 }
52973
52974
52975 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
52976   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
52977   int arg2 ;
52978   int arg3 ;
52979
52980   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52981   arg2 = (int)jarg2;
52982   arg3 = (int)jarg3;
52983   {
52984     try {
52985       try {
52986         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
52987       }
52988       catch(std::out_of_range &_e) {
52989         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52990         return ;
52991       }
52992       catch(std::invalid_argument &_e) {
52993         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
52994         return ;
52995       }
52996
52997     } CALL_CATCH_EXCEPTION();
52998   }
52999
53000 }
53001
53002
53003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
53004   void * jresult ;
53005   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
53006   int arg2 ;
53007   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
53008
53009   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
53010   if (!arg1) {
53011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
53012     return 0;
53013   }
53014   arg2 = (int)jarg2;
53015   {
53016     try {
53017       try {
53018         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);
53019       }
53020       catch(std::out_of_range &_e) {
53021         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53022         return 0;
53023       }
53024
53025     } CALL_CATCH_EXCEPTION(0);
53026   }
53027
53028   jresult = (void *)result;
53029   return jresult;
53030 }
53031
53032
53033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
53034   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
53035
53036   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
53037   {
53038     try {
53039       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
53040     } CALL_CATCH_EXCEPTION();
53041   }
53042
53043 }
53044
53045
53046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
53047   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
53048   int arg2 ;
53049   int arg3 ;
53050
53051   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
53052   arg2 = (int)jarg2;
53053   arg3 = (int)jarg3;
53054   {
53055     try {
53056       try {
53057         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
53058       }
53059       catch(std::out_of_range &_e) {
53060         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53061         return ;
53062       }
53063       catch(std::invalid_argument &_e) {
53064         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
53065         return ;
53066       }
53067
53068     } CALL_CATCH_EXCEPTION();
53069   }
53070
53071 }
53072
53073
53074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
53075   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
53076   int arg2 ;
53077   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
53078
53079   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
53080   arg2 = (int)jarg2;
53081   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
53082   if (!arg3) {
53083     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
53084     return ;
53085   }
53086   {
53087     try {
53088       try {
53089         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);
53090       }
53091       catch(std::out_of_range &_e) {
53092         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53093         return ;
53094       }
53095
53096     } CALL_CATCH_EXCEPTION();
53097   }
53098
53099 }
53100
53101
53102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
53103   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
53104
53105   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
53106   {
53107     try {
53108       delete arg1;
53109     } CALL_CATCH_EXCEPTION();
53110   }
53111
53112 }
53113
53114
53115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
53116   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53117
53118   arg1 = (std::vector< Dali::Actor > *)jarg1;
53119   {
53120     try {
53121       (arg1)->clear();
53122     } CALL_CATCH_EXCEPTION();
53123   }
53124
53125 }
53126
53127
53128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
53129   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53130   Dali::Actor *arg2 = 0 ;
53131
53132   arg1 = (std::vector< Dali::Actor > *)jarg1;
53133   arg2 = (Dali::Actor *)jarg2;
53134   if (!arg2) {
53135     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
53136     return ;
53137   }
53138   {
53139     try {
53140       (arg1)->push_back((Dali::Actor const &)*arg2);
53141     } CALL_CATCH_EXCEPTION();
53142   }
53143
53144 }
53145
53146
53147 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
53148   unsigned long jresult ;
53149   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53150   std::vector< Dali::Actor >::size_type result;
53151
53152   arg1 = (std::vector< Dali::Actor > *)jarg1;
53153   {
53154     try {
53155       result = ((std::vector< Dali::Actor > const *)arg1)->size();
53156     } CALL_CATCH_EXCEPTION(0);
53157   }
53158
53159   jresult = (unsigned long)result;
53160   return jresult;
53161 }
53162
53163
53164 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
53165   unsigned long jresult ;
53166   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53167   std::vector< Dali::Actor >::size_type result;
53168
53169   arg1 = (std::vector< Dali::Actor > *)jarg1;
53170   {
53171     try {
53172       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
53173     } CALL_CATCH_EXCEPTION(0);
53174   }
53175
53176   jresult = (unsigned long)result;
53177   return jresult;
53178 }
53179
53180
53181 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
53182   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53183   std::vector< Dali::Actor >::size_type arg2 ;
53184
53185   arg1 = (std::vector< Dali::Actor > *)jarg1;
53186   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
53187   {
53188     try {
53189       (arg1)->reserve(arg2);
53190     } CALL_CATCH_EXCEPTION();
53191   }
53192
53193 }
53194
53195
53196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
53197   void * jresult ;
53198   std::vector< Dali::Actor > *result = 0 ;
53199
53200   {
53201     try {
53202       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
53203     } CALL_CATCH_EXCEPTION(0);
53204   }
53205
53206   jresult = (void *)result;
53207   return jresult;
53208 }
53209
53210
53211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
53212   void * jresult ;
53213   std::vector< Dali::Actor > *arg1 = 0 ;
53214   std::vector< Dali::Actor > *result = 0 ;
53215
53216   arg1 = (std::vector< Dali::Actor > *)jarg1;
53217   if (!arg1) {
53218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
53219     return 0;
53220   }
53221   {
53222     try {
53223       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
53224     } CALL_CATCH_EXCEPTION(0);
53225   }
53226
53227   jresult = (void *)result;
53228   return jresult;
53229 }
53230
53231
53232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
53233   void * jresult ;
53234   int arg1 ;
53235   std::vector< Dali::Actor > *result = 0 ;
53236
53237   arg1 = (int)jarg1;
53238   {
53239     try {
53240       try {
53241         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
53242       }
53243       catch(std::out_of_range &_e) {
53244         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53245         return 0;
53246       }
53247
53248     } CALL_CATCH_EXCEPTION(0);
53249   }
53250
53251   jresult = (void *)result;
53252   return jresult;
53253 }
53254
53255
53256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
53257   void * jresult ;
53258   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53259   int arg2 ;
53260   Dali::Actor result;
53261
53262   arg1 = (std::vector< Dali::Actor > *)jarg1;
53263   arg2 = (int)jarg2;
53264   {
53265     try {
53266       try {
53267         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
53268       }
53269       catch(std::out_of_range &_e) {
53270         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53271         return 0;
53272       }
53273
53274     } CALL_CATCH_EXCEPTION(0);
53275   }
53276
53277   jresult = new Dali::Actor((const Dali::Actor &)result);
53278   return jresult;
53279 }
53280
53281
53282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
53283   void * jresult ;
53284   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53285   int arg2 ;
53286   Dali::Actor *result = 0 ;
53287
53288   arg1 = (std::vector< Dali::Actor > *)jarg1;
53289   arg2 = (int)jarg2;
53290   {
53291     try {
53292       try {
53293         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
53294       }
53295       catch(std::out_of_range &_e) {
53296         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53297         return 0;
53298       }
53299
53300     } CALL_CATCH_EXCEPTION(0);
53301   }
53302
53303   jresult = (void *)result;
53304   return jresult;
53305 }
53306
53307
53308 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
53309   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53310   int arg2 ;
53311   Dali::Actor *arg3 = 0 ;
53312
53313   arg1 = (std::vector< Dali::Actor > *)jarg1;
53314   arg2 = (int)jarg2;
53315   arg3 = (Dali::Actor *)jarg3;
53316   if (!arg3) {
53317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
53318     return ;
53319   }
53320   {
53321     try {
53322       try {
53323         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
53324       }
53325       catch(std::out_of_range &_e) {
53326         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53327         return ;
53328       }
53329
53330     } CALL_CATCH_EXCEPTION();
53331   }
53332
53333 }
53334
53335
53336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
53337   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53338   std::vector< Dali::Actor > *arg2 = 0 ;
53339
53340   arg1 = (std::vector< Dali::Actor > *)jarg1;
53341   arg2 = (std::vector< Dali::Actor > *)jarg2;
53342   if (!arg2) {
53343     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
53344     return ;
53345   }
53346   {
53347     try {
53348       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
53349     } CALL_CATCH_EXCEPTION();
53350   }
53351
53352 }
53353
53354
53355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
53356   void * jresult ;
53357   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53358   int arg2 ;
53359   int arg3 ;
53360   std::vector< Dali::Actor > *result = 0 ;
53361
53362   arg1 = (std::vector< Dali::Actor > *)jarg1;
53363   arg2 = (int)jarg2;
53364   arg3 = (int)jarg3;
53365   {
53366     try {
53367       try {
53368         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
53369       }
53370       catch(std::out_of_range &_e) {
53371         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53372         return 0;
53373       }
53374       catch(std::invalid_argument &_e) {
53375         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
53376         return 0;
53377       }
53378
53379     } CALL_CATCH_EXCEPTION(0);
53380   }
53381
53382   jresult = (void *)result;
53383   return jresult;
53384 }
53385
53386
53387 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
53388   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53389   int arg2 ;
53390   Dali::Actor *arg3 = 0 ;
53391
53392   arg1 = (std::vector< Dali::Actor > *)jarg1;
53393   arg2 = (int)jarg2;
53394   arg3 = (Dali::Actor *)jarg3;
53395   if (!arg3) {
53396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
53397     return ;
53398   }
53399   {
53400     try {
53401       try {
53402         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
53403       }
53404       catch(std::out_of_range &_e) {
53405         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53406         return ;
53407       }
53408
53409     } CALL_CATCH_EXCEPTION();
53410   }
53411
53412 }
53413
53414
53415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
53416   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53417   int arg2 ;
53418   std::vector< Dali::Actor > *arg3 = 0 ;
53419
53420   arg1 = (std::vector< Dali::Actor > *)jarg1;
53421   arg2 = (int)jarg2;
53422   arg3 = (std::vector< Dali::Actor > *)jarg3;
53423   if (!arg3) {
53424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
53425     return ;
53426   }
53427   {
53428     try {
53429       try {
53430         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
53431       }
53432       catch(std::out_of_range &_e) {
53433         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53434         return ;
53435       }
53436
53437     } CALL_CATCH_EXCEPTION();
53438   }
53439
53440 }
53441
53442
53443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
53444   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53445   int arg2 ;
53446
53447   arg1 = (std::vector< Dali::Actor > *)jarg1;
53448   arg2 = (int)jarg2;
53449   {
53450     try {
53451       try {
53452         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
53453       }
53454       catch(std::out_of_range &_e) {
53455         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53456         return ;
53457       }
53458
53459     } CALL_CATCH_EXCEPTION();
53460   }
53461
53462 }
53463
53464
53465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
53466   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53467   int arg2 ;
53468   int arg3 ;
53469
53470   arg1 = (std::vector< Dali::Actor > *)jarg1;
53471   arg2 = (int)jarg2;
53472   arg3 = (int)jarg3;
53473   {
53474     try {
53475       try {
53476         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
53477       }
53478       catch(std::out_of_range &_e) {
53479         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53480         return ;
53481       }
53482       catch(std::invalid_argument &_e) {
53483         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
53484         return ;
53485       }
53486
53487     } CALL_CATCH_EXCEPTION();
53488   }
53489
53490 }
53491
53492
53493 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
53494   void * jresult ;
53495   Dali::Actor *arg1 = 0 ;
53496   int arg2 ;
53497   std::vector< Dali::Actor > *result = 0 ;
53498
53499   arg1 = (Dali::Actor *)jarg1;
53500   if (!arg1) {
53501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
53502     return 0;
53503   }
53504   arg2 = (int)jarg2;
53505   {
53506     try {
53507       try {
53508         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
53509       }
53510       catch(std::out_of_range &_e) {
53511         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53512         return 0;
53513       }
53514
53515     } CALL_CATCH_EXCEPTION(0);
53516   }
53517
53518   jresult = (void *)result;
53519   return jresult;
53520 }
53521
53522
53523 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
53524   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53525
53526   arg1 = (std::vector< Dali::Actor > *)jarg1;
53527   {
53528     try {
53529       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
53530     } CALL_CATCH_EXCEPTION();
53531   }
53532
53533 }
53534
53535
53536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
53537   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53538   int arg2 ;
53539   int arg3 ;
53540
53541   arg1 = (std::vector< Dali::Actor > *)jarg1;
53542   arg2 = (int)jarg2;
53543   arg3 = (int)jarg3;
53544   {
53545     try {
53546       try {
53547         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
53548       }
53549       catch(std::out_of_range &_e) {
53550         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53551         return ;
53552       }
53553       catch(std::invalid_argument &_e) {
53554         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
53555         return ;
53556       }
53557
53558     } CALL_CATCH_EXCEPTION();
53559   }
53560
53561 }
53562
53563
53564 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
53565   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53566   int arg2 ;
53567   std::vector< Dali::Actor > *arg3 = 0 ;
53568
53569   arg1 = (std::vector< Dali::Actor > *)jarg1;
53570   arg2 = (int)jarg2;
53571   arg3 = (std::vector< Dali::Actor > *)jarg3;
53572   if (!arg3) {
53573     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
53574     return ;
53575   }
53576   {
53577     try {
53578       try {
53579         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
53580       }
53581       catch(std::out_of_range &_e) {
53582         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53583         return ;
53584       }
53585
53586     } CALL_CATCH_EXCEPTION();
53587   }
53588
53589 }
53590
53591
53592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
53593   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53594
53595   arg1 = (std::vector< Dali::Actor > *)jarg1;
53596   {
53597     try {
53598       delete arg1;
53599     } CALL_CATCH_EXCEPTION();
53600   }
53601
53602 }
53603
53604
53605 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
53606   unsigned int jresult ;
53607   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
53608   bool result;
53609
53610   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
53611   {
53612     try {
53613       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
53614     } CALL_CATCH_EXCEPTION(0);
53615   }
53616
53617   jresult = result;
53618   return jresult;
53619 }
53620
53621
53622 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
53623   unsigned long jresult ;
53624   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
53625   std::size_t result;
53626
53627   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
53628   {
53629     try {
53630       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
53631     } CALL_CATCH_EXCEPTION(0);
53632   }
53633
53634   jresult = (unsigned long)result;
53635   return jresult;
53636 }
53637
53638
53639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
53640   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
53641   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
53642
53643   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
53644   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
53645   {
53646     try {
53647       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
53648     } CALL_CATCH_EXCEPTION();
53649   }
53650
53651 }
53652
53653
53654 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
53655   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
53656   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
53657
53658   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
53659   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
53660   {
53661     try {
53662       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
53663     } CALL_CATCH_EXCEPTION();
53664   }
53665
53666 }
53667
53668
53669 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
53670   unsigned int jresult ;
53671   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
53672   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
53673   bool result;
53674
53675   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
53676   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
53677   if (!arg2) {
53678     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
53679     return 0;
53680   }
53681   {
53682     try {
53683       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
53684     } CALL_CATCH_EXCEPTION(0);
53685   }
53686
53687   jresult = result;
53688   return jresult;
53689 }
53690
53691
53692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
53693   void * jresult ;
53694   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
53695
53696   {
53697     try {
53698       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
53699     } CALL_CATCH_EXCEPTION(0);
53700   }
53701
53702   jresult = (void *)result;
53703   return jresult;
53704 }
53705
53706
53707 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
53708   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
53709
53710   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
53711   {
53712     try {
53713       delete arg1;
53714     } CALL_CATCH_EXCEPTION();
53715   }
53716
53717 }
53718
53719
53720 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
53721   unsigned int jresult ;
53722   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
53723   bool result;
53724
53725   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
53726   {
53727     try {
53728       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);
53729     } CALL_CATCH_EXCEPTION(0);
53730   }
53731
53732   jresult = result;
53733   return jresult;
53734 }
53735
53736
53737 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
53738   unsigned long jresult ;
53739   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
53740   std::size_t result;
53741
53742   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
53743   {
53744     try {
53745       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);
53746     } CALL_CATCH_EXCEPTION(0);
53747   }
53748
53749   jresult = (unsigned long)result;
53750   return jresult;
53751 }
53752
53753
53754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
53755   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
53756   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
53757
53758   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
53759   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
53760   {
53761     try {
53762       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
53763     } CALL_CATCH_EXCEPTION();
53764   }
53765
53766 }
53767
53768
53769 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
53770   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
53771   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
53772
53773   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
53774   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
53775   {
53776     try {
53777       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
53778     } CALL_CATCH_EXCEPTION();
53779   }
53780
53781 }
53782
53783
53784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
53785   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
53786   Dali::Actor arg2 ;
53787   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
53788   Dali::Actor *argp2 ;
53789
53790   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
53791   argp2 = (Dali::Actor *)jarg2;
53792   if (!argp2) {
53793     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
53794     return ;
53795   }
53796   arg2 = *argp2;
53797   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
53798   {
53799     try {
53800       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
53801     } CALL_CATCH_EXCEPTION();
53802   }
53803
53804 }
53805
53806
53807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
53808   void * jresult ;
53809   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
53810
53811   {
53812     try {
53813       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
53814     } CALL_CATCH_EXCEPTION(0);
53815   }
53816
53817   jresult = (void *)result;
53818   return jresult;
53819 }
53820
53821
53822 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
53823   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
53824
53825   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
53826   {
53827     try {
53828       delete arg1;
53829     } CALL_CATCH_EXCEPTION();
53830   }
53831
53832 }
53833
53834
53835 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
53836   unsigned int jresult ;
53837   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
53838   bool result;
53839
53840   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
53841   {
53842     try {
53843       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
53844     } CALL_CATCH_EXCEPTION(0);
53845   }
53846
53847   jresult = result;
53848   return jresult;
53849 }
53850
53851
53852 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
53853   unsigned long jresult ;
53854   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
53855   std::size_t result;
53856
53857   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
53858   {
53859     try {
53860       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
53861     } CALL_CATCH_EXCEPTION(0);
53862   }
53863
53864   jresult = (unsigned long)result;
53865   return jresult;
53866 }
53867
53868
53869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
53870   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
53871   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
53872
53873   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
53874   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
53875   {
53876     try {
53877       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
53878     } CALL_CATCH_EXCEPTION();
53879   }
53880
53881 }
53882
53883
53884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
53885   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
53886   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
53887
53888   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
53889   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
53890   {
53891     try {
53892       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
53893     } CALL_CATCH_EXCEPTION();
53894   }
53895
53896 }
53897
53898
53899 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
53900   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
53901   Dali::Actor arg2 ;
53902   Dali::Actor arg3 ;
53903   Dali::Actor *argp2 ;
53904   Dali::Actor *argp3 ;
53905
53906   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
53907   argp2 = (Dali::Actor *)jarg2;
53908   if (!argp2) {
53909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
53910     return ;
53911   }
53912   arg2 = *argp2;
53913   argp3 = (Dali::Actor *)jarg3;
53914   if (!argp3) {
53915     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
53916     return ;
53917   }
53918   arg3 = *argp3;
53919   {
53920     try {
53921       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
53922     } CALL_CATCH_EXCEPTION();
53923   }
53924
53925 }
53926
53927
53928 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
53929   void * jresult ;
53930   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
53931
53932   {
53933     try {
53934       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
53935     } CALL_CATCH_EXCEPTION(0);
53936   }
53937
53938   jresult = (void *)result;
53939   return jresult;
53940 }
53941
53942
53943 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
53944   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
53945
53946   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
53947   {
53948     try {
53949       delete arg1;
53950     } CALL_CATCH_EXCEPTION();
53951   }
53952
53953 }
53954
53955
53956 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
53957   unsigned int jresult ;
53958   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
53959   bool result;
53960
53961   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
53962   {
53963     try {
53964       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
53965     } CALL_CATCH_EXCEPTION(0);
53966   }
53967
53968   jresult = result;
53969   return jresult;
53970 }
53971
53972
53973 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
53974   unsigned long jresult ;
53975   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
53976   std::size_t result;
53977
53978   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
53979   {
53980     try {
53981       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
53982     } CALL_CATCH_EXCEPTION(0);
53983   }
53984
53985   jresult = (unsigned long)result;
53986   return jresult;
53987 }
53988
53989
53990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
53991   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
53992   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
53993
53994   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
53995   arg2 = (void (*)(Dali::Actor,bool))jarg2;
53996   {
53997     try {
53998       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
53999     } CALL_CATCH_EXCEPTION();
54000   }
54001
54002 }
54003
54004
54005 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
54006   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
54007   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
54008
54009   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
54010   arg2 = (void (*)(Dali::Actor,bool))jarg2;
54011   {
54012     try {
54013       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
54014     } CALL_CATCH_EXCEPTION();
54015   }
54016
54017 }
54018
54019
54020 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
54021   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
54022   Dali::Actor arg2 ;
54023   bool arg3 ;
54024   Dali::Actor *argp2 ;
54025
54026   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
54027   argp2 = (Dali::Actor *)jarg2;
54028   if (!argp2) {
54029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
54030     return ;
54031   }
54032   arg2 = *argp2;
54033   arg3 = jarg3 ? true : false;
54034   {
54035     try {
54036       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
54037     } CALL_CATCH_EXCEPTION();
54038   }
54039
54040 }
54041
54042
54043 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
54044   void * jresult ;
54045   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
54046
54047   {
54048     try {
54049       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
54050     } CALL_CATCH_EXCEPTION(0);
54051   }
54052
54053   jresult = (void *)result;
54054   return jresult;
54055 }
54056
54057
54058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
54059   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
54060
54061   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
54062   {
54063     try {
54064       delete arg1;
54065     } CALL_CATCH_EXCEPTION();
54066   }
54067
54068 }
54069
54070
54071 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
54072   unsigned int jresult ;
54073   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
54074   bool result;
54075
54076   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
54077   {
54078     try {
54079       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);
54080     } CALL_CATCH_EXCEPTION(0);
54081   }
54082
54083   jresult = result;
54084   return jresult;
54085 }
54086
54087
54088 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
54089   unsigned long jresult ;
54090   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
54091   std::size_t result;
54092
54093   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
54094   {
54095     try {
54096       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);
54097     } CALL_CATCH_EXCEPTION(0);
54098   }
54099
54100   jresult = (unsigned long)result;
54101   return jresult;
54102 }
54103
54104
54105 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
54106   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
54107   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
54108
54109   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
54110   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
54111   {
54112     try {
54113       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
54114     } CALL_CATCH_EXCEPTION();
54115   }
54116
54117 }
54118
54119
54120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
54121   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
54122   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
54123
54124   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
54125   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
54126   {
54127     try {
54128       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
54129     } CALL_CATCH_EXCEPTION();
54130   }
54131
54132 }
54133
54134
54135 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
54136   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
54137   Dali::Toolkit::StyleManager arg2 ;
54138   Dali::StyleChange::Type arg3 ;
54139   Dali::Toolkit::StyleManager *argp2 ;
54140
54141   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
54142   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
54143   if (!argp2) {
54144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
54145     return ;
54146   }
54147   arg2 = *argp2;
54148   arg3 = (Dali::StyleChange::Type)jarg3;
54149   {
54150     try {
54151       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
54152     } CALL_CATCH_EXCEPTION();
54153   }
54154
54155 }
54156
54157
54158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
54159   void * jresult ;
54160   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
54161
54162   {
54163     try {
54164       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
54165     } CALL_CATCH_EXCEPTION(0);
54166   }
54167
54168   jresult = (void *)result;
54169   return jresult;
54170 }
54171
54172
54173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
54174   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
54175
54176   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
54177   {
54178     try {
54179       delete arg1;
54180     } CALL_CATCH_EXCEPTION();
54181   }
54182
54183 }
54184
54185
54186 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
54187   unsigned int jresult ;
54188   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
54189   bool result;
54190
54191   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
54192   {
54193     try {
54194       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
54195     } CALL_CATCH_EXCEPTION(0);
54196   }
54197
54198   jresult = result;
54199   return jresult;
54200 }
54201
54202
54203 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
54204   unsigned long jresult ;
54205   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
54206   std::size_t result;
54207
54208   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
54209   {
54210     try {
54211       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
54212     } CALL_CATCH_EXCEPTION(0);
54213   }
54214
54215   jresult = (unsigned long)result;
54216   return jresult;
54217 }
54218
54219
54220 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
54221   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
54222   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
54223
54224   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
54225   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
54226   {
54227     try {
54228       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
54229     } CALL_CATCH_EXCEPTION();
54230   }
54231
54232 }
54233
54234
54235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
54236   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
54237   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
54238
54239   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
54240   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
54241   {
54242     try {
54243       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
54244     } CALL_CATCH_EXCEPTION();
54245   }
54246
54247 }
54248
54249
54250 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
54251   unsigned int jresult ;
54252   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
54253   Dali::Toolkit::Button arg2 ;
54254   Dali::Toolkit::Button *argp2 ;
54255   bool result;
54256
54257   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
54258   argp2 = (Dali::Toolkit::Button *)jarg2;
54259   if (!argp2) {
54260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
54261     return 0;
54262   }
54263   arg2 = *argp2;
54264   {
54265     try {
54266       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
54267     } CALL_CATCH_EXCEPTION(0);
54268   }
54269
54270   jresult = result;
54271   return jresult;
54272 }
54273
54274
54275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
54276   void * jresult ;
54277   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
54278
54279   {
54280     try {
54281       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
54282     } CALL_CATCH_EXCEPTION(0);
54283   }
54284
54285   jresult = (void *)result;
54286   return jresult;
54287 }
54288
54289
54290 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
54291   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
54292
54293   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
54294   {
54295     try {
54296       delete arg1;
54297     } CALL_CATCH_EXCEPTION();
54298   }
54299
54300 }
54301
54302
54303 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
54304   unsigned int jresult ;
54305   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
54306   bool result;
54307
54308   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
54309   {
54310     try {
54311       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
54312     } CALL_CATCH_EXCEPTION(0);
54313   }
54314
54315   jresult = result;
54316   return jresult;
54317 }
54318
54319
54320 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
54321   unsigned long jresult ;
54322   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
54323   std::size_t result;
54324
54325   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
54326   {
54327     try {
54328       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
54329     } CALL_CATCH_EXCEPTION(0);
54330   }
54331
54332   jresult = (unsigned long)result;
54333   return jresult;
54334 }
54335
54336
54337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
54338   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
54339   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
54340
54341   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
54342   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
54343   {
54344     try {
54345       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
54346     } CALL_CATCH_EXCEPTION();
54347   }
54348
54349 }
54350
54351
54352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
54353   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
54354   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
54355
54356   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
54357   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
54358   {
54359     try {
54360       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
54361     } CALL_CATCH_EXCEPTION();
54362   }
54363
54364 }
54365
54366
54367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
54368   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
54369   Dali::Toolkit::GaussianBlurView arg2 ;
54370   Dali::Toolkit::GaussianBlurView *argp2 ;
54371
54372   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
54373   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
54374   if (!argp2) {
54375     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
54376     return ;
54377   }
54378   arg2 = *argp2;
54379   {
54380     try {
54381       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
54382     } CALL_CATCH_EXCEPTION();
54383   }
54384
54385 }
54386
54387
54388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
54389   void * jresult ;
54390   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
54391
54392   {
54393     try {
54394       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
54395     } CALL_CATCH_EXCEPTION(0);
54396   }
54397
54398   jresult = (void *)result;
54399   return jresult;
54400 }
54401
54402
54403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
54404   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
54405
54406   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
54407   {
54408     try {
54409       delete arg1;
54410     } CALL_CATCH_EXCEPTION();
54411   }
54412
54413 }
54414
54415
54416 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
54417   unsigned int jresult ;
54418   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
54419   bool result;
54420
54421   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
54422   {
54423     try {
54424       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);
54425     } CALL_CATCH_EXCEPTION(0);
54426   }
54427
54428   jresult = result;
54429   return jresult;
54430 }
54431
54432
54433 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
54434   unsigned long jresult ;
54435   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
54436   std::size_t result;
54437
54438   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
54439   {
54440     try {
54441       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);
54442     } CALL_CATCH_EXCEPTION(0);
54443   }
54444
54445   jresult = (unsigned long)result;
54446   return jresult;
54447 }
54448
54449
54450 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
54451   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
54452   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
54453
54454   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
54455   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
54456   {
54457     try {
54458       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
54459     } CALL_CATCH_EXCEPTION();
54460   }
54461
54462 }
54463
54464
54465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
54466   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
54467   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
54468
54469   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
54470   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
54471   {
54472     try {
54473       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
54474     } CALL_CATCH_EXCEPTION();
54475   }
54476
54477 }
54478
54479
54480 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
54481   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
54482   Dali::Toolkit::PageTurnView arg2 ;
54483   unsigned int arg3 ;
54484   bool arg4 ;
54485   Dali::Toolkit::PageTurnView *argp2 ;
54486
54487   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
54488   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
54489   if (!argp2) {
54490     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
54491     return ;
54492   }
54493   arg2 = *argp2;
54494   arg3 = (unsigned int)jarg3;
54495   arg4 = jarg4 ? true : false;
54496   {
54497     try {
54498       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
54499     } CALL_CATCH_EXCEPTION();
54500   }
54501
54502 }
54503
54504
54505 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
54506   void * jresult ;
54507   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
54508
54509   {
54510     try {
54511       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
54512     } CALL_CATCH_EXCEPTION(0);
54513   }
54514
54515   jresult = (void *)result;
54516   return jresult;
54517 }
54518
54519
54520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
54521   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
54522
54523   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
54524   {
54525     try {
54526       delete arg1;
54527     } CALL_CATCH_EXCEPTION();
54528   }
54529
54530 }
54531
54532
54533 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
54534   unsigned int jresult ;
54535   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
54536   bool result;
54537
54538   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
54539   {
54540     try {
54541       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
54542     } CALL_CATCH_EXCEPTION(0);
54543   }
54544
54545   jresult = result;
54546   return jresult;
54547 }
54548
54549
54550 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
54551   unsigned long jresult ;
54552   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
54553   std::size_t result;
54554
54555   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
54556   {
54557     try {
54558       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
54559     } CALL_CATCH_EXCEPTION(0);
54560   }
54561
54562   jresult = (unsigned long)result;
54563   return jresult;
54564 }
54565
54566
54567 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
54568   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
54569   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
54570
54571   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
54572   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
54573   {
54574     try {
54575       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
54576     } CALL_CATCH_EXCEPTION();
54577   }
54578 }
54579
54580
54581 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
54582   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
54583   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
54584
54585   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
54586   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
54587   {
54588     try {
54589       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
54590     } CALL_CATCH_EXCEPTION();
54591   }
54592 }
54593
54594
54595 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
54596   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
54597   Dali::Toolkit::PageTurnView arg2 ;
54598   Dali::Toolkit::PageTurnView *argp2 ;
54599
54600   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
54601   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
54602   if (!argp2) {
54603     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
54604     return ;
54605   }
54606   arg2 = *argp2;
54607   {
54608     try {
54609       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
54610     } CALL_CATCH_EXCEPTION();
54611   }
54612 }
54613
54614
54615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
54616   void * jresult ;
54617   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
54618
54619   {
54620     try {
54621       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
54622     } CALL_CATCH_EXCEPTION(0);
54623   }
54624
54625   jresult = (void *)result;
54626   return jresult;
54627 }
54628
54629
54630 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
54631   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
54632
54633   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
54634   {
54635     try {
54636       delete arg1;
54637     } CALL_CATCH_EXCEPTION();
54638   }
54639
54640 }
54641
54642
54643 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
54644   unsigned int jresult ;
54645   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
54646   bool result;
54647
54648   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
54649   {
54650     try {
54651       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);
54652     } CALL_CATCH_EXCEPTION(0);
54653   }
54654
54655   jresult = result;
54656   return jresult;
54657 }
54658
54659
54660 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
54661   unsigned long jresult ;
54662   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
54663   std::size_t result;
54664
54665   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
54666   {
54667     try {
54668       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);
54669     } CALL_CATCH_EXCEPTION(0);
54670   }
54671
54672   jresult = (unsigned long)result;
54673   return jresult;
54674 }
54675
54676
54677 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
54678   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
54679   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
54680
54681   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
54682   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
54683   {
54684     try {
54685       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
54686     } CALL_CATCH_EXCEPTION();
54687   }
54688
54689 }
54690
54691
54692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
54693   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
54694   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
54695
54696   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
54697   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
54698   {
54699     try {
54700       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
54701     } CALL_CATCH_EXCEPTION();
54702   }
54703
54704 }
54705
54706
54707 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
54708   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
54709   Dali::Toolkit::ProgressBar arg2 ;
54710   float arg3 ;
54711   float arg4 ;
54712   Dali::Toolkit::ProgressBar *argp2 ;
54713
54714   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
54715   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
54716   if (!argp2) {
54717     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
54718     return ;
54719   }
54720   arg2 = *argp2;
54721   arg3 = (float)jarg3;
54722   arg4 = (float)jarg4;
54723   {
54724     try {
54725       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
54726     } CALL_CATCH_EXCEPTION();
54727   }
54728
54729 }
54730
54731
54732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
54733   void * jresult ;
54734   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
54735
54736   {
54737     try {
54738       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
54739     } CALL_CATCH_EXCEPTION(0);
54740   }
54741
54742   jresult = (void *)result;
54743   return jresult;
54744 }
54745
54746
54747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
54748   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
54749
54750   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
54751   {
54752     try {
54753       delete arg1;
54754     } CALL_CATCH_EXCEPTION();
54755   }
54756
54757 }
54758
54759
54760 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
54761   unsigned int jresult ;
54762   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
54763   bool result;
54764
54765   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
54766   {
54767     try {
54768       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);
54769     } CALL_CATCH_EXCEPTION(0);
54770   }
54771
54772   jresult = result;
54773   return jresult;
54774 }
54775
54776
54777 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
54778   unsigned long jresult ;
54779   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
54780   std::size_t result;
54781
54782   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
54783   {
54784     try {
54785       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);
54786     } CALL_CATCH_EXCEPTION(0);
54787   }
54788
54789   jresult = (unsigned long)result;
54790   return jresult;
54791 }
54792
54793
54794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
54795   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
54796   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
54797
54798   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
54799   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
54800   {
54801     try {
54802       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
54803     } CALL_CATCH_EXCEPTION();
54804   }
54805
54806 }
54807
54808
54809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
54810   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
54811   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
54812
54813   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
54814   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
54815   {
54816     try {
54817       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
54818     } CALL_CATCH_EXCEPTION();
54819   }
54820
54821 }
54822
54823
54824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
54825   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
54826   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
54827
54828   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
54829   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
54830   if (!arg2) {
54831     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
54832     return ;
54833   }
54834   {
54835     try {
54836       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
54837     } CALL_CATCH_EXCEPTION();
54838   }
54839
54840 }
54841
54842
54843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
54844   void * jresult ;
54845   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
54846
54847   {
54848     try {
54849       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
54850     } CALL_CATCH_EXCEPTION(0);
54851   }
54852
54853   jresult = (void *)result;
54854   return jresult;
54855 }
54856
54857
54858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
54859   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
54860
54861   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
54862   {
54863     try {
54864       delete arg1;
54865     } CALL_CATCH_EXCEPTION();
54866   }
54867
54868 }
54869
54870
54871 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
54872   unsigned int jresult ;
54873   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
54874   bool result;
54875
54876   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
54877   {
54878     try {
54879       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
54880     } CALL_CATCH_EXCEPTION(0);
54881   }
54882
54883   jresult = result;
54884   return jresult;
54885 }
54886
54887
54888 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
54889   unsigned long jresult ;
54890   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
54891   std::size_t result;
54892
54893   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
54894   {
54895     try {
54896       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
54897     } CALL_CATCH_EXCEPTION(0);
54898   }
54899
54900   jresult = (unsigned long)result;
54901   return jresult;
54902 }
54903
54904
54905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
54906   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
54907   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
54908
54909   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
54910   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
54911   {
54912     try {
54913       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
54914     } CALL_CATCH_EXCEPTION();
54915   }
54916
54917 }
54918
54919
54920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
54921   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
54922   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
54923
54924   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
54925   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
54926   {
54927     try {
54928       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
54929     } CALL_CATCH_EXCEPTION();
54930   }
54931
54932 }
54933
54934
54935 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
54936   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
54937   Dali::Vector2 *arg2 = 0 ;
54938
54939   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
54940   arg2 = (Dali::Vector2 *)jarg2;
54941   if (!arg2) {
54942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
54943     return ;
54944   }
54945   {
54946     try {
54947       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
54948     } CALL_CATCH_EXCEPTION();
54949   }
54950
54951 }
54952
54953
54954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
54955   void * jresult ;
54956   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
54957
54958   {
54959     try {
54960       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
54961     } CALL_CATCH_EXCEPTION(0);
54962   }
54963
54964   jresult = (void *)result;
54965   return jresult;
54966 }
54967
54968
54969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
54970   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
54971
54972   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
54973   {
54974     try {
54975       delete arg1;
54976     } CALL_CATCH_EXCEPTION();
54977   }
54978
54979 }
54980
54981
54982
54983 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
54984   unsigned int jresult ;
54985   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
54986   bool result;
54987
54988   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
54989   {
54990     try {
54991       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);
54992     } CALL_CATCH_EXCEPTION(0);
54993   }
54994
54995   jresult = result;
54996   return jresult;
54997 }
54998
54999
55000 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
55001   unsigned long jresult ;
55002   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
55003   std::size_t result;
55004
55005   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
55006   {
55007     try {
55008       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);
55009     } CALL_CATCH_EXCEPTION(0);
55010   }
55011
55012   jresult = (unsigned long)result;
55013   return jresult;
55014 }
55015
55016
55017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
55018   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
55019   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
55020
55021   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
55022   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
55023   {
55024     try {
55025       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55026     } CALL_CATCH_EXCEPTION();
55027   }
55028
55029 }
55030
55031
55032 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
55033   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
55034   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
55035
55036   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
55037   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
55038   {
55039     try {
55040       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55041     } CALL_CATCH_EXCEPTION();
55042   }
55043
55044 }
55045
55046
55047 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55048   unsigned int jresult ;
55049   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
55050   Dali::Toolkit::Control arg2 ;
55051   Dali::KeyEvent *arg3 = 0 ;
55052   Dali::Toolkit::Control *argp2 ;
55053   bool result;
55054
55055   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
55056   argp2 = (Dali::Toolkit::Control *)jarg2;
55057   if (!argp2) {
55058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
55059     return 0;
55060   }
55061   arg2 = *argp2;
55062   arg3 = (Dali::KeyEvent *)jarg3;
55063   if (!arg3) {
55064     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
55065     return 0;
55066   }
55067   {
55068     try {
55069       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);
55070     } CALL_CATCH_EXCEPTION(0);
55071   }
55072
55073   jresult = result;
55074   return jresult;
55075 }
55076
55077
55078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
55079   void * jresult ;
55080   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
55081
55082   {
55083     try {
55084       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
55085     } CALL_CATCH_EXCEPTION(0);
55086   }
55087
55088   jresult = (void *)result;
55089   return jresult;
55090 }
55091
55092
55093 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
55094   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
55095
55096   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
55097   {
55098     try {
55099       delete arg1;
55100     } CALL_CATCH_EXCEPTION();
55101   }
55102
55103 }
55104
55105
55106 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
55107   unsigned int jresult ;
55108   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
55109   bool result;
55110
55111   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
55112   {
55113     try {
55114       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
55115     } CALL_CATCH_EXCEPTION(0);
55116   }
55117
55118   jresult = result;
55119   return jresult;
55120 }
55121
55122
55123 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
55124   unsigned long jresult ;
55125   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
55126   std::size_t result;
55127
55128   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
55129   {
55130     try {
55131       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
55132     } CALL_CATCH_EXCEPTION(0);
55133   }
55134
55135   jresult = (unsigned long)result;
55136   return jresult;
55137 }
55138
55139
55140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
55141   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
55142   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
55143
55144   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
55145   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
55146   {
55147     try {
55148       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
55149     } CALL_CATCH_EXCEPTION();
55150   }
55151
55152 }
55153
55154
55155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
55156   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
55157   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
55158
55159   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
55160   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
55161   {
55162     try {
55163       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
55164     } CALL_CATCH_EXCEPTION();
55165   }
55166
55167 }
55168
55169
55170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
55171   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
55172   Dali::Toolkit::Control arg2 ;
55173   Dali::Toolkit::Control *argp2 ;
55174
55175   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
55176   argp2 = (Dali::Toolkit::Control *)jarg2;
55177   if (!argp2) {
55178     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
55179     return ;
55180   }
55181   arg2 = *argp2;
55182   {
55183     try {
55184       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
55185     } CALL_CATCH_EXCEPTION();
55186   }
55187
55188 }
55189
55190
55191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
55192   void * jresult ;
55193   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
55194
55195   {
55196     try {
55197       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
55198     } CALL_CATCH_EXCEPTION(0);
55199   }
55200
55201   jresult = (void *)result;
55202   return jresult;
55203 }
55204
55205
55206 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
55207   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
55208
55209   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
55210   {
55211     try {
55212       delete arg1;
55213     } CALL_CATCH_EXCEPTION();
55214   }
55215
55216 }
55217
55218
55219 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
55220   unsigned int jresult ;
55221   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
55222   bool result;
55223
55224   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
55225   {
55226     try {
55227       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
55228     } CALL_CATCH_EXCEPTION(0);
55229   }
55230
55231   jresult = result;
55232   return jresult;
55233 }
55234
55235
55236 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
55237   unsigned long jresult ;
55238   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
55239   std::size_t result;
55240
55241   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
55242   {
55243     try {
55244       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
55245     } CALL_CATCH_EXCEPTION(0);
55246   }
55247
55248   jresult = (unsigned long)result;
55249   return jresult;
55250 }
55251
55252
55253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
55254   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
55255   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
55256
55257   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
55258   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
55259   {
55260     try {
55261       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
55262     } CALL_CATCH_EXCEPTION();
55263   }
55264
55265 }
55266
55267
55268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
55269   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
55270   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
55271
55272   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
55273   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
55274   {
55275     try {
55276       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
55277     } CALL_CATCH_EXCEPTION();
55278   }
55279
55280 }
55281
55282
55283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
55284   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
55285   Dali::Toolkit::VideoView *arg2 = 0 ;
55286
55287   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
55288   arg2 = (Dali::Toolkit::VideoView *)jarg2;
55289   if (!arg2) {
55290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
55291     return ;
55292   }
55293   {
55294     try {
55295       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
55296     } CALL_CATCH_EXCEPTION();
55297   }
55298
55299 }
55300
55301
55302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
55303   void * jresult ;
55304   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
55305
55306   {
55307     try {
55308       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
55309     } CALL_CATCH_EXCEPTION(0);
55310   }
55311
55312   jresult = (void *)result;
55313   return jresult;
55314 }
55315
55316
55317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
55318   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
55319
55320   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
55321   {
55322     try {
55323       delete arg1;
55324     } CALL_CATCH_EXCEPTION();
55325   }
55326
55327 }
55328
55329
55330 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
55331   unsigned int jresult ;
55332   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
55333   bool result;
55334
55335   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
55336   {
55337     try {
55338       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
55339     } CALL_CATCH_EXCEPTION(0);
55340   }
55341
55342   jresult = result;
55343   return jresult;
55344 }
55345
55346
55347 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
55348   unsigned long jresult ;
55349   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
55350   std::size_t result;
55351
55352   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
55353   {
55354     try {
55355       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
55356     } CALL_CATCH_EXCEPTION(0);
55357   }
55358
55359   jresult = (unsigned long)result;
55360   return jresult;
55361 }
55362
55363
55364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
55365   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
55366   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
55367
55368   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
55369   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
55370   {
55371     try {
55372       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
55373     } CALL_CATCH_EXCEPTION();
55374   }
55375
55376 }
55377
55378
55379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
55380   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
55381   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
55382
55383   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
55384   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
55385   {
55386     try {
55387       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
55388     } CALL_CATCH_EXCEPTION();
55389   }
55390
55391 }
55392
55393
55394 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
55395   unsigned int jresult ;
55396   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
55397   Dali::Toolkit::Slider arg2 ;
55398   float arg3 ;
55399   Dali::Toolkit::Slider *argp2 ;
55400   bool result;
55401
55402   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
55403   argp2 = (Dali::Toolkit::Slider *)jarg2;
55404   if (!argp2) {
55405     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
55406     return 0;
55407   }
55408   arg2 = *argp2;
55409   arg3 = (float)jarg3;
55410   {
55411     try {
55412       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
55413     } CALL_CATCH_EXCEPTION(0);
55414   }
55415
55416   jresult = result;
55417   return jresult;
55418 }
55419
55420
55421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
55422   void * jresult ;
55423   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
55424
55425   {
55426     try {
55427       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
55428     } CALL_CATCH_EXCEPTION(0);
55429   }
55430
55431   jresult = (void *)result;
55432   return jresult;
55433 }
55434
55435
55436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
55437   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
55438
55439   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
55440   {
55441     try {
55442       delete arg1;
55443     } CALL_CATCH_EXCEPTION();
55444   }
55445
55446 }
55447
55448
55449 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
55450   unsigned int jresult ;
55451   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
55452   bool result;
55453
55454   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
55455   {
55456     try {
55457       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
55458     } CALL_CATCH_EXCEPTION(0);
55459   }
55460
55461   jresult = result;
55462   return jresult;
55463 }
55464
55465
55466 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
55467   unsigned long jresult ;
55468   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
55469   std::size_t result;
55470
55471   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
55472   {
55473     try {
55474       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
55475     } CALL_CATCH_EXCEPTION(0);
55476   }
55477
55478   jresult = (unsigned long)result;
55479   return jresult;
55480 }
55481
55482
55483 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
55484   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
55485   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
55486
55487   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
55488   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
55489   {
55490     try {
55491       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
55492     } CALL_CATCH_EXCEPTION();
55493   }
55494
55495 }
55496
55497
55498 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
55499   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
55500   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
55501
55502   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
55503   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
55504   {
55505     try {
55506       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
55507     } CALL_CATCH_EXCEPTION();
55508   }
55509
55510 }
55511
55512
55513 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
55514   unsigned int jresult ;
55515   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
55516   Dali::Toolkit::Slider arg2 ;
55517   int arg3 ;
55518   Dali::Toolkit::Slider *argp2 ;
55519   bool result;
55520
55521   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
55522   argp2 = (Dali::Toolkit::Slider *)jarg2;
55523   if (!argp2) {
55524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
55525     return 0;
55526   }
55527   arg2 = *argp2;
55528   arg3 = (int)jarg3;
55529   {
55530     try {
55531       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
55532     } CALL_CATCH_EXCEPTION(0);
55533   }
55534
55535   jresult = result;
55536   return jresult;
55537 }
55538
55539
55540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
55541   void * jresult ;
55542   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
55543
55544   {
55545     try {
55546       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
55547     } CALL_CATCH_EXCEPTION(0);
55548   }
55549
55550   jresult = (void *)result;
55551   return jresult;
55552 }
55553
55554
55555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
55556   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
55557
55558   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
55559   {
55560     try {
55561       delete arg1;
55562     } CALL_CATCH_EXCEPTION();
55563   }
55564
55565 }
55566
55567
55568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
55569   void * jresult ;
55570   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
55571
55572   {
55573     try {
55574       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
55575     } CALL_CATCH_EXCEPTION(0);
55576   }
55577
55578   jresult = (void *)result;
55579   return jresult;
55580 }
55581
55582
55583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
55584   void * jresult ;
55585   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
55586   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
55587
55588   arg1 = (Dali::Toolkit::Ruler *)jarg1;
55589   {
55590     try {
55591       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
55592     } CALL_CATCH_EXCEPTION(0);
55593   }
55594
55595   jresult = (void *)result;
55596   return jresult;
55597 }
55598
55599
55600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
55601   void * jresult ;
55602   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
55603   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
55604
55605   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55606   if (!arg1) {
55607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
55608     return 0;
55609   }
55610   {
55611     try {
55612       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
55613     } CALL_CATCH_EXCEPTION(0);
55614   }
55615
55616   jresult = (void *)result;
55617   return jresult;
55618 }
55619
55620
55621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
55622   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55623
55624   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55625   {
55626     try {
55627       delete arg1;
55628     } CALL_CATCH_EXCEPTION();
55629   }
55630
55631 }
55632
55633
55634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
55635   void * jresult ;
55636   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55637   Dali::Toolkit::Ruler *result = 0 ;
55638
55639   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55640   {
55641     try {
55642       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
55643     } CALL_CATCH_EXCEPTION(0);
55644   }
55645
55646   jresult = (void *)result;
55647   return jresult;
55648 }
55649
55650
55651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
55652   void * jresult ;
55653   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55654   Dali::Toolkit::Ruler *result = 0 ;
55655
55656   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55657   {
55658     try {
55659       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
55660     } CALL_CATCH_EXCEPTION(0);
55661   }
55662
55663   jresult = (void *)result;
55664   return jresult;
55665 }
55666
55667
55668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
55669   void * jresult ;
55670   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55671   Dali::Toolkit::Ruler *result = 0 ;
55672
55673   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55674   {
55675     try {
55676       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
55677     } CALL_CATCH_EXCEPTION(0);
55678   }
55679
55680   jresult = (void *)result;
55681   return jresult;
55682 }
55683
55684
55685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
55686   void * jresult ;
55687   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55688   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
55689   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
55690
55691   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55692   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
55693   if (!arg2) {
55694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
55695     return 0;
55696   }
55697   {
55698     try {
55699       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
55700     } CALL_CATCH_EXCEPTION(0);
55701   }
55702
55703   jresult = (void *)result;
55704   return jresult;
55705 }
55706
55707
55708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
55709   void * jresult ;
55710   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55711   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
55712   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
55713
55714   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55715   arg2 = (Dali::Toolkit::Ruler *)jarg2;
55716   {
55717     try {
55718       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
55719     } CALL_CATCH_EXCEPTION(0);
55720   }
55721
55722   jresult = (void *)result;
55723   return jresult;
55724 }
55725
55726
55727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
55728   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55729
55730   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55731   {
55732     try {
55733       (arg1)->Reset();
55734     } CALL_CATCH_EXCEPTION();
55735   }
55736
55737 }
55738
55739
55740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
55741   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55742   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
55743
55744   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55745   arg2 = (Dali::Toolkit::Ruler *)jarg2;
55746   {
55747     try {
55748       (arg1)->Reset(arg2);
55749     } CALL_CATCH_EXCEPTION();
55750   }
55751
55752 }
55753
55754
55755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
55756   void * jresult ;
55757   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55758   Dali::Toolkit::Ruler *result = 0 ;
55759
55760   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55761   {
55762     try {
55763       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
55764     } CALL_CATCH_EXCEPTION(0);
55765   }
55766
55767   jresult = (void *)result;
55768   return jresult;
55769 }
55770
55771
55772 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
55773   float jresult ;
55774   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55775   float arg2 ;
55776   float arg3 ;
55777   float result;
55778
55779   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55780   arg2 = (float)jarg2;
55781   arg3 = (float)jarg3;
55782   {
55783     try {
55784       result = (float)(*arg1)->Snap(arg2,arg3);
55785     } CALL_CATCH_EXCEPTION(0);
55786   }
55787
55788   jresult = result;
55789   return jresult;
55790 }
55791
55792
55793 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
55794   float jresult ;
55795   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55796   float arg2 ;
55797   float result;
55798
55799   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55800   arg2 = (float)jarg2;
55801   {
55802     try {
55803       result = (float)(*arg1)->Snap(arg2);
55804     } CALL_CATCH_EXCEPTION(0);
55805   }
55806
55807   jresult = result;
55808   return jresult;
55809 }
55810
55811
55812 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
55813   float jresult ;
55814   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55815   unsigned int arg2 ;
55816   unsigned int *arg3 = 0 ;
55817   bool arg4 ;
55818   float result;
55819
55820   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55821   arg2 = (unsigned int)jarg2;
55822   arg3 = (unsigned int *)jarg3;
55823   arg4 = jarg4 ? true : false;
55824   {
55825     try {
55826       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
55827     } CALL_CATCH_EXCEPTION(0);
55828   }
55829
55830   jresult = result;
55831   return jresult;
55832 }
55833
55834
55835 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
55836   unsigned int jresult ;
55837   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55838   float arg2 ;
55839   bool arg3 ;
55840   unsigned int result;
55841
55842   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55843   arg2 = (float)jarg2;
55844   arg3 = jarg3 ? true : false;
55845   {
55846     try {
55847       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
55848     } CALL_CATCH_EXCEPTION(0);
55849   }
55850
55851   jresult = result;
55852   return jresult;
55853 }
55854
55855
55856 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
55857   unsigned int jresult ;
55858   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55859   unsigned int result;
55860
55861   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55862   {
55863     try {
55864       result = (unsigned int)(*arg1)->GetTotalPages();
55865     } CALL_CATCH_EXCEPTION(0);
55866   }
55867
55868   jresult = result;
55869   return jresult;
55870 }
55871
55872
55873 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
55874   int jresult ;
55875   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55876   Dali::Toolkit::Ruler::RulerType result;
55877
55878   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55879   {
55880     try {
55881       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
55882     } CALL_CATCH_EXCEPTION(0);
55883   }
55884
55885   jresult = (int)result;
55886   return jresult;
55887 }
55888
55889
55890 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
55891   unsigned int jresult ;
55892   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55893   bool result;
55894
55895   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55896   {
55897     try {
55898       result = (bool)(*arg1)->IsEnabled();
55899     } CALL_CATCH_EXCEPTION(0);
55900   }
55901
55902   jresult = result;
55903   return jresult;
55904 }
55905
55906
55907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
55908   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55909
55910   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55911   {
55912     try {
55913       (*arg1)->Enable();
55914     } CALL_CATCH_EXCEPTION();
55915   }
55916
55917 }
55918
55919
55920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
55921   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55922
55923   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55924   {
55925     try {
55926       (*arg1)->Disable();
55927     } CALL_CATCH_EXCEPTION();
55928   }
55929
55930 }
55931
55932
55933 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
55934   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55935   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
55936   Dali::Toolkit::RulerDomain *argp2 ;
55937
55938   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55939   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
55940   if (!argp2) {
55941     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
55942     return ;
55943   }
55944   arg2 = *argp2;
55945   {
55946     try {
55947       (*arg1)->SetDomain(arg2);
55948     } CALL_CATCH_EXCEPTION();
55949   }
55950
55951 }
55952
55953
55954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
55955   void * jresult ;
55956   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55957   Dali::Toolkit::RulerDomain *result = 0 ;
55958
55959   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55960   {
55961     try {
55962       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
55963     } CALL_CATCH_EXCEPTION(0);
55964   }
55965
55966   jresult = (void *)result;
55967   return jresult;
55968 }
55969
55970
55971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
55972   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55973
55974   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55975   {
55976     try {
55977       (*arg1)->DisableDomain();
55978     } CALL_CATCH_EXCEPTION();
55979   }
55980
55981 }
55982
55983
55984 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
55985   float jresult ;
55986   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55987   float arg2 ;
55988   float arg3 ;
55989   float arg4 ;
55990   float result;
55991
55992   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55993   arg2 = (float)jarg2;
55994   arg3 = (float)jarg3;
55995   arg4 = (float)jarg4;
55996   {
55997     try {
55998       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
55999     } CALL_CATCH_EXCEPTION(0);
56000   }
56001
56002   jresult = result;
56003   return jresult;
56004 }
56005
56006
56007 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
56008   float jresult ;
56009   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
56010   float arg2 ;
56011   float arg3 ;
56012   float result;
56013
56014   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
56015   arg2 = (float)jarg2;
56016   arg3 = (float)jarg3;
56017   {
56018     try {
56019       result = (float)(*arg1)->Clamp(arg2,arg3);
56020     } CALL_CATCH_EXCEPTION(0);
56021   }
56022
56023   jresult = result;
56024   return jresult;
56025 }
56026
56027
56028 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
56029   float jresult ;
56030   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
56031   float arg2 ;
56032   float result;
56033
56034   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
56035   arg2 = (float)jarg2;
56036   {
56037     try {
56038       result = (float)(*arg1)->Clamp(arg2);
56039     } CALL_CATCH_EXCEPTION(0);
56040   }
56041
56042   jresult = result;
56043   return jresult;
56044 }
56045
56046
56047 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
56048   float jresult ;
56049   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
56050   float arg2 ;
56051   float arg3 ;
56052   float arg4 ;
56053   Dali::Toolkit::ClampState *arg5 = 0 ;
56054   float result;
56055
56056   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
56057   arg2 = (float)jarg2;
56058   arg3 = (float)jarg3;
56059   arg4 = (float)jarg4;
56060   arg5 = (Dali::Toolkit::ClampState *)jarg5;
56061   if (!arg5) {
56062     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
56063     return 0;
56064   }
56065   {
56066     try {
56067       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
56068     } CALL_CATCH_EXCEPTION(0);
56069   }
56070
56071   jresult = result;
56072   return jresult;
56073 }
56074
56075
56076 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
56077   float jresult ;
56078   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
56079   float arg2 ;
56080   float arg3 ;
56081   float arg4 ;
56082   float arg5 ;
56083   float result;
56084
56085   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
56086   arg2 = (float)jarg2;
56087   arg3 = (float)jarg3;
56088   arg4 = (float)jarg4;
56089   arg5 = (float)jarg5;
56090   {
56091     try {
56092       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
56093     } CALL_CATCH_EXCEPTION(0);
56094   }
56095
56096   jresult = result;
56097   return jresult;
56098 }
56099
56100
56101 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
56102   float jresult ;
56103   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
56104   float arg2 ;
56105   float arg3 ;
56106   float arg4 ;
56107   float result;
56108
56109   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
56110   arg2 = (float)jarg2;
56111   arg3 = (float)jarg3;
56112   arg4 = (float)jarg4;
56113   {
56114     try {
56115       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
56116     } CALL_CATCH_EXCEPTION(0);
56117   }
56118
56119   jresult = result;
56120   return jresult;
56121 }
56122
56123
56124 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
56125   float jresult ;
56126   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
56127   float arg2 ;
56128   float arg3 ;
56129   float result;
56130
56131   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
56132   arg2 = (float)jarg2;
56133   arg3 = (float)jarg3;
56134   {
56135     try {
56136       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
56137     } CALL_CATCH_EXCEPTION(0);
56138   }
56139
56140   jresult = result;
56141   return jresult;
56142 }
56143
56144
56145 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
56146   float jresult ;
56147   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
56148   float arg2 ;
56149   float result;
56150
56151   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
56152   arg2 = (float)jarg2;
56153   {
56154     try {
56155       result = (float)(*arg1)->SnapAndClamp(arg2);
56156     } CALL_CATCH_EXCEPTION(0);
56157   }
56158
56159   jresult = result;
56160   return jresult;
56161 }
56162
56163
56164 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
56165   float jresult ;
56166   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
56167   float arg2 ;
56168   float arg3 ;
56169   float arg4 ;
56170   float arg5 ;
56171   Dali::Toolkit::ClampState *arg6 = 0 ;
56172   float result;
56173
56174   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
56175   arg2 = (float)jarg2;
56176   arg3 = (float)jarg3;
56177   arg4 = (float)jarg4;
56178   arg5 = (float)jarg5;
56179   arg6 = (Dali::Toolkit::ClampState *)jarg6;
56180   if (!arg6) {
56181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
56182     return 0;
56183   }
56184   {
56185     try {
56186       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
56187     } CALL_CATCH_EXCEPTION(0);
56188   }
56189
56190   jresult = result;
56191   return jresult;
56192 }
56193
56194
56195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
56196   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
56197
56198   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
56199   {
56200     try {
56201       (*arg1)->Reference();
56202     } CALL_CATCH_EXCEPTION();
56203   }
56204
56205 }
56206
56207
56208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
56209   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
56210
56211   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
56212   {
56213     try {
56214       (*arg1)->Unreference();
56215     } CALL_CATCH_EXCEPTION();
56216   }
56217
56218 }
56219
56220
56221 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
56222   int jresult ;
56223   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
56224   int result;
56225
56226   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
56227   {
56228     try {
56229       result = (int)(*arg1)->ReferenceCount();
56230     } CALL_CATCH_EXCEPTION(0);
56231   }
56232
56233   jresult = result;
56234   return jresult;
56235 }
56236
56237
56238 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Empty(void * jarg1) {
56239   unsigned int jresult ;
56240   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
56241   bool result;
56242
56243   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
56244   {
56245     try {
56246       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
56247     } CALL_CATCH_EXCEPTION(0);
56248   }
56249
56250   jresult = result;
56251   return jresult;
56252 }
56253
56254
56255 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_GetConnectionCount(void * jarg1) {
56256   unsigned long jresult ;
56257   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
56258   std::size_t result;
56259
56260   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
56261   {
56262     try {
56263       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
56264     } CALL_CATCH_EXCEPTION(0);
56265   }
56266
56267   jresult = (unsigned long)result;
56268   return jresult;
56269 }
56270
56271
56272 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Connect(void * jarg1, void * jarg2) {
56273   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
56274   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
56275
56276   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
56277   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
56278   {
56279     try {
56280       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
56281     } CALL_CATCH_EXCEPTION();
56282   }
56283
56284 }
56285
56286
56287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Disconnect(void * jarg1, void * jarg2) {
56288   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
56289   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
56290
56291   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
56292   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
56293   {
56294     try {
56295       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
56296     } CALL_CATCH_EXCEPTION();
56297   }
56298
56299 }
56300
56301
56302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Emit(void * jarg1, void * jarg2) {
56303   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
56304   Dali::Toolkit::Control arg2 ;
56305   Dali::Toolkit::Control *argp2 ;
56306
56307   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
56308   argp2 = (Dali::Toolkit::Control *)jarg2;
56309   if (!argp2) {
56310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
56311     return ;
56312   }
56313   arg2 = *argp2;
56314   {
56315     try {
56316       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
56317     } CALL_CATCH_EXCEPTION();
56318   }
56319
56320 }
56321
56322
56323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewResourceReadySignal() {
56324   void * jresult ;
56325   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
56326
56327   {
56328     try {
56329       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
56330     } CALL_CATCH_EXCEPTION(0);
56331   }
56332
56333   jresult = (void *)result;
56334   return jresult;
56335 }
56336
56337
56338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewResourceReadySignal(void * jarg1) {
56339   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
56340
56341   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
56342   {
56343     try {
56344       delete arg1;
56345     } CALL_CATCH_EXCEPTION();
56346   }
56347
56348 }
56349
56350 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_GetRefObjectPtr(Dali::BaseHandle *arg1) {
56351   Dali::RefObject *result = NULL;
56352
56353   if (arg1)
56354   {
56355     result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
56356   }
56357   return result;
56358 }
56359
56360 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
56361     return (Dali::RefObject *)jarg1;
56362 }
56363
56364 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
56365     return (Dali::SignalObserver *)jarg1;
56366 }
56367
56368 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
56369     return (Dali::ConnectionTrackerInterface *)jarg1;
56370 }
56371
56372 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
56373     return (Dali::BaseHandle *)jarg1;
56374 }
56375
56376 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
56377     return (Dali::BaseHandle *)jarg1;
56378 }
56379
56380 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
56381     return (Dali::BaseHandle *)jarg1;
56382 }
56383
56384 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
56385     return (Dali::BaseHandle *)jarg1;
56386 }
56387
56388 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
56389     return (Dali::BaseHandle *)jarg1;
56390 }
56391
56392 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
56393     return (Dali::BaseHandle *)jarg1;
56394 }
56395
56396 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
56397     return (Dali::BaseHandle *)jarg1;
56398 }
56399
56400 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
56401     return (Dali::BaseHandle *)jarg1;
56402 }
56403
56404 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
56405     return (Dali::BaseHandle *)jarg1;
56406 }
56407
56408 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
56409     return (Dali::BaseHandle *)jarg1;
56410 }
56411
56412 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VertexBuffer_SWIGUpcast(Dali::VertexBuffer *jarg1) {
56413     return (Dali::BaseHandle *)jarg1;
56414 }
56415
56416 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
56417     return (Dali::BaseHandle *)jarg1;
56418 }
56419
56420 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
56421     return (Dali::Handle *)jarg1;
56422 }
56423
56424 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
56425     return (Dali::Handle *)jarg1;
56426 }
56427
56428 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
56429     return (Dali::BaseHandle *)jarg1;
56430 }
56431
56432 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
56433     return (Dali::BaseHandle *)jarg1;
56434 }
56435
56436 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
56437     return (Dali::Handle *)jarg1;
56438 }
56439
56440 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchEvent *jarg1) {
56441     return (Dali::BaseHandle *)jarg1;
56442 }
56443
56444 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Hover_SWIGUpcast(Dali::HoverEvent *jarg1) {
56445     return (Dali::BaseHandle *)jarg1;
56446 }
56447
56448 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Wheel_SWIGUpcast(Dali::WheelEvent *jarg1) {
56449     return (Dali::BaseHandle *)jarg1;
56450 }
56451
56452 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Key_SWIGUpcast(Dali::KeyEvent *jarg1) {
56453     return (Dali::BaseHandle *)jarg1;
56454 }
56455
56456 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
56457     return (Dali::Handle *)jarg1;
56458 }
56459
56460 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
56461     return (Dali::GestureDetector *)jarg1;
56462 }
56463
56464 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
56465     return (Dali::Gesture *)jarg1;
56466 }
56467
56468 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
56469     return (Dali::Handle *)jarg1;
56470 }
56471
56472 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
56473     return (Dali::Actor *)jarg1;
56474 }
56475
56476 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
56477     return (Dali::RefObject *)jarg1;
56478 }
56479
56480 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
56481     return (Dali::Actor *)jarg1;
56482 }
56483
56484 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
56485     return (Dali::GestureDetector *)jarg1;
56486 }
56487
56488 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
56489     return (Dali::Gesture *)jarg1;
56490 }
56491
56492 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
56493     return (Dali::GestureDetector *)jarg1;
56494 }
56495
56496 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
56497     return (Dali::Gesture *)jarg1;
56498 }
56499
56500 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
56501     return (Dali::GestureDetector *)jarg1;
56502 }
56503
56504 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
56505     return (Dali::Gesture *)jarg1;
56506 }
56507
56508 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
56509     return (Dali::BaseHandle *)jarg1;
56510 }
56511
56512 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
56513     return (Dali::Handle *)jarg1;
56514 }
56515
56516 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
56517     return (Dali::Handle *)jarg1;
56518 }
56519
56520 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
56521     return (Dali::Handle *)jarg1;
56522 }
56523
56524 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
56525     return (Dali::RefObject *)jarg1;
56526 }
56527
56528 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
56529     return (Dali::Actor *)jarg1;
56530 }
56531
56532 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
56533     return (Dali::BaseHandle *)jarg1;
56534 }
56535
56536 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
56537     return (Dali::BaseHandle *)jarg1;
56538 }
56539
56540 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
56541     return (Dali::BaseHandle *)jarg1;
56542 }
56543
56544 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
56545     return (Dali::CustomActorImpl *)jarg1;
56546 }
56547
56548 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
56549     return (Dali::CustomActor *)jarg1;
56550 }
56551
56552 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
56553     return (Dali::BaseHandle *)jarg1;
56554 }
56555
56556 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
56557     return (Dali::Toolkit::Control *)jarg1;
56558 }
56559
56560 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
56561     return (Dali::Toolkit::Control *)jarg1;
56562 }
56563
56564 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
56565     return (Dali::Toolkit::Button *)jarg1;
56566 }
56567
56568 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
56569     return (Dali::Toolkit::Button *)jarg1;
56570 }
56571
56572 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
56573     return (Dali::Toolkit::Button *)jarg1;
56574 }
56575
56576 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
56577     return (Dali::Toolkit::Control *)jarg1;
56578 }
56579
56580 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
56581     return (Dali::Toolkit::Control *)jarg1;
56582 }
56583
56584 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
56585     return (Dali::Toolkit::Control *)jarg1;
56586 }
56587
56588 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
56589     return (Dali::Toolkit::Control *)jarg1;
56590 }
56591
56592 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
56593     return (Dali::Toolkit::Control *)jarg1;
56594 }
56595
56596 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
56597     return (Dali::RefObject *)jarg1;
56598 }
56599
56600 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
56601     return (Dali::Toolkit::Scrollable *)jarg1;
56602 }
56603
56604 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
56605     return (Dali::BaseHandle *)jarg1;
56606 }
56607
56608 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
56609     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
56610 }
56611
56612 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
56613     return (Dali::RefObject *)jarg1;
56614 }
56615
56616 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
56617     return (Dali::Toolkit::Ruler *)jarg1;
56618 }
56619
56620 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
56621     return (Dali::Toolkit::Ruler *)jarg1;
56622 }
56623
56624 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
56625     return (Dali::Toolkit::Scrollable *)jarg1;
56626 }
56627
56628 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
56629     return (Dali::Toolkit::Control *)jarg1;
56630 }
56631
56632
56633 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
56634     return (Dali::Toolkit::Control *)jarg1;
56635 }
56636
56637 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
56638     return (Dali::BaseHandle *)jarg1;
56639 }
56640
56641 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
56642     return (Dali::BaseHandle *)jarg1;
56643 }
56644
56645 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
56646     return (Dali::Toolkit::Control *)jarg1;
56647 }
56648
56649 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
56650     return (Dali::Toolkit::Control *)jarg1;
56651 }
56652
56653 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
56654     return (Dali::Toolkit::Control *)jarg1;
56655 }
56656
56657 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
56658     return (Dali::Toolkit::Control *)jarg1;
56659 }
56660
56661 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
56662     return (Dali::Toolkit::Control *)jarg1;
56663 }
56664
56665 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
56666     return (Dali::Toolkit::Control *)jarg1;
56667 }
56668
56669 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
56670     return (Dali::Toolkit::PageTurnView *)jarg1;
56671 }
56672
56673 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
56674     return (Dali::Toolkit::PageTurnView *)jarg1;
56675 }
56676
56677 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
56678     return (Dali::Toolkit::Button *)jarg1;
56679 }
56680
56681 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
56682     return (Dali::BaseHandle *)jarg1;
56683 }
56684
56685 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
56686     return (Dali::BaseHandle *)jarg1;
56687 }
56688
56689 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
56690     return (Dali::BaseHandle *)jarg1;
56691 }
56692
56693 /*
56694  * Widget binding
56695  */
56696 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Widget_SWIGUpcast(Dali::Widget *jarg1) {
56697     return (Dali::BaseHandle *)jarg1;
56698 }
56699
56700 SWIGEXPORT Dali::BaseObject * SWIGSTDCALL CSharp_Dali_WidgetImpl_SWIGUpcast(Dali::Internal::Adaptor::Widget *jarg1) {
56701     return (Dali::BaseObject *)jarg1;
56702 }
56703
56704 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_0() {
56705   void * jresult ;
56706   Dali::Widget result;
56707
56708   {
56709     try {
56710       result = Dali::Widget::New();
56711     } CALL_CATCH_EXCEPTION(0);
56712   }
56713
56714   jresult = new Dali::Widget((const Dali::Widget &)result);
56715   return jresult;
56716 }
56717
56718
56719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_1(void * jarg1) {
56720   void * jresult ;
56721   Dali::Internal::Adaptor::Widget *arg1 = 0 ;
56722   Dali::Widget result;
56723
56724   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
56725
56726   if (!arg1) {
56727     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Internal::Adaptor::Widget & type is null", 0);
56728     return 0;
56729   }
56730   {
56731     try {
56732       jresult = new Dali::Widget(arg1);
56733     } CALL_CATCH_EXCEPTION(0);
56734   }
56735   return jresult;
56736 }
56737
56738 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Widget() {
56739   void * jresult ;
56740   Dali::Widget *result = 0 ;
56741
56742   {
56743     try {
56744       result = (Dali::Widget *)new Dali::Widget();
56745     } CALL_CATCH_EXCEPTION(0);
56746   }
56747   jresult = (void *)result;
56748   return jresult;
56749 }
56750
56751
56752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_Assign(void * jarg1, void * jarg2) {
56753   void * jresult ;
56754   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
56755   Dali::Widget *arg2 = 0 ;
56756   Dali::Widget *result = 0 ;
56757
56758   arg1 = (Dali::Widget *)jarg1;
56759   arg2 = (Dali::Widget *)jarg2;
56760   if (!arg2) {
56761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget const & type is null", 0);
56762     return 0;
56763   }
56764   {
56765     try {
56766       result = (Dali::Widget *) &(arg1)->operator =((Dali::Widget const &)*arg2);
56767     } CALL_CATCH_EXCEPTION(0);
56768   }
56769   jresult = (void *)result;
56770   return jresult;
56771 }
56772
56773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Widget(void * jarg1) {
56774   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
56775
56776   arg1 = (Dali::Widget *)jarg1;
56777   {
56778     try {
56779       delete arg1;
56780     } CALL_CATCH_EXCEPTION();
56781   }
56782 }
56783
56784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetImpl_New() {
56785   void * jresult ;
56786   SwigDirector_WidgetImpl* result;
56787   {
56788     try {
56789       result = new SwigDirector_WidgetImpl();
56790     } CALL_CATCH_EXCEPTION(0);
56791   }
56792   jresult = result;
56793   return jresult;
56794 }
56795
56796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreate(void * jarg1, char * jarg2, void * jarg3) {
56797   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
56798   std::string *arg2 = 0 ;
56799   Dali::Window arg3 ;
56800   Dali::Window *argp3 ;
56801
56802   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
56803   if (!jarg2) {
56804     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
56805     return ;
56806   }
56807   std::string arg2_str(jarg2);
56808   arg2 = &arg2_str;
56809   argp3 = (Dali::Window *)jarg3;
56810   if (!argp3) {
56811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
56812     return ;
56813   }
56814   arg3 = *argp3;
56815   {
56816     try {
56817       (arg1)->OnCreate((std::string const &)*arg2,arg3);
56818     } CALL_CATCH_EXCEPTION();
56819   }
56820 }
56821
56822
56823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, void * jarg3) {
56824   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
56825   std::string *arg2 = 0 ;
56826   Dali::Window arg3 ;
56827   Dali::Window *argp3 ;
56828
56829   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
56830   if (!jarg2) {
56831     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
56832     return ;
56833   }
56834   std::string arg2_str(jarg2);
56835   arg2 = &arg2_str;
56836   argp3 = (Dali::Window *)jarg3;
56837   if (!argp3) {
56838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
56839     return ;
56840   }
56841   arg3 = *argp3;
56842   {
56843     try {
56844       (arg1)->Dali::Internal::Adaptor::Widget::OnCreate((std::string const &)*arg2,arg3);
56845     } CALL_CATCH_EXCEPTION();
56846   }
56847 }
56848
56849
56850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminate(void * jarg1, char * jarg2, int jarg3) {
56851   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
56852   std::string *arg2 = 0 ;
56853   Dali::Widget::Termination arg3 ;
56854
56855   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
56856   if (!jarg2) {
56857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
56858     return ;
56859   }
56860   std::string arg2_str(jarg2);
56861   arg2 = &arg2_str;
56862   arg3 = (Dali::Widget::Termination)jarg3;
56863   {
56864     try {
56865       (arg1)->OnTerminate((std::string const &)*arg2,arg3);
56866     } CALL_CATCH_EXCEPTION();
56867   }
56868 }
56869
56870
56871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
56872   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
56873   std::string *arg2 = 0 ;
56874   Dali::Widget::Termination arg3 ;
56875
56876   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
56877   if (!jarg2) {
56878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
56879     return ;
56880   }
56881   std::string arg2_str(jarg2);
56882   arg2 = &arg2_str;
56883   arg3 = (Dali::Widget::Termination)jarg3;
56884   {
56885     try {
56886       (arg1)->Dali::Internal::Adaptor::Widget::OnTerminate((std::string const &)*arg2,arg3);
56887     } CALL_CATCH_EXCEPTION();
56888   }
56889 }
56890
56891
56892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPause(void * jarg1) {
56893   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
56894
56895   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
56896   {
56897     try {
56898       (arg1)->OnPause();
56899     } CALL_CATCH_EXCEPTION();
56900   }
56901 }
56902
56903
56904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPauseSwigExplicitWidgetImpl(void * jarg1) {
56905   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
56906
56907   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
56908   {
56909     try {
56910       (arg1)->Dali::Internal::Adaptor::Widget::OnPause();
56911     } CALL_CATCH_EXCEPTION();
56912   }
56913 }
56914
56915
56916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResume(void * jarg1) {
56917   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
56918
56919   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
56920   {
56921     try {
56922       (arg1)->OnResume();
56923     } CALL_CATCH_EXCEPTION();
56924   }
56925 }
56926
56927
56928 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResumeSwigExplicitWidgetImpl(void * jarg1) {
56929   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
56930
56931   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
56932   {
56933     try {
56934       (arg1)->Dali::Internal::Adaptor::Widget::OnResume();
56935     } CALL_CATCH_EXCEPTION();
56936   }
56937 }
56938
56939
56940 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResize(void * jarg1, void * jarg2) {
56941   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
56942   Dali::Window arg2 ;
56943   Dali::Window *argp2 ;
56944
56945   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
56946   argp2 = (Dali::Window *)jarg2;
56947   if (!argp2) {
56948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
56949     return ;
56950   }
56951   arg2 = *argp2;
56952   {
56953     try {
56954       (arg1)->OnResize(arg2);
56955     } CALL_CATCH_EXCEPTION();
56956   }
56957 }
56958
56959
56960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResizeSwigExplicitWidgetImpl(void * jarg1, void * jarg2) {
56961   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
56962   Dali::Window arg2 ;
56963   Dali::Window *argp2 ;
56964
56965   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
56966   argp2 = (Dali::Window *)jarg2;
56967   if (!argp2) {
56968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
56969     return ;
56970   }
56971   arg2 = *argp2;
56972   {
56973     try {
56974       (arg1)->Dali::Internal::Adaptor::Widget::OnResize(arg2);
56975     } CALL_CATCH_EXCEPTION();
56976   }
56977 }
56978
56979
56980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdate(void * jarg1, char * jarg2, int jarg3) {
56981   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
56982   std::string *arg2 = 0 ;
56983   int arg3 ;
56984
56985   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
56986   if (!jarg2) {
56987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
56988     return ;
56989   }
56990   std::string arg2_str(jarg2);
56991   arg2 = &arg2_str;
56992   arg3 = (int)jarg3;
56993   {
56994     try {
56995       (arg1)->OnUpdate((std::string const &)*arg2,arg3);
56996     } CALL_CATCH_EXCEPTION();
56997   }
56998 }
56999
57000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
57001   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
57002   std::string *arg2 = 0 ;
57003   int arg3 ;
57004
57005   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
57006   if (!jarg2) {
57007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57008     return ;
57009   }
57010   std::string arg2_str(jarg2);
57011   arg2 = &arg2_str;
57012   arg3 = (int)jarg3;
57013   {
57014     try {
57015       (arg1)->Dali::Internal::Adaptor::Widget::OnUpdate((std::string const &)*arg2,arg3);
57016     } CALL_CATCH_EXCEPTION();
57017   }
57018 }
57019
57020
57021 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
57022   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
57023   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
57024   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
57025
57026   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
57027   arg2 = (Dali::SlotObserver *)jarg2;
57028   arg3 = (Dali::CallbackBase *)jarg3;
57029   {
57030     try {
57031       (arg1)->SignalConnected(arg2,arg3);
57032     } CALL_CATCH_EXCEPTION();
57033   }
57034 }
57035
57036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
57037   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
57038   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
57039   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
57040
57041   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
57042   arg2 = (Dali::SlotObserver *)jarg2;
57043   arg3 = (Dali::CallbackBase *)jarg3;
57044   {
57045     try {
57046       (arg1)->Dali::Internal::Adaptor::Widget::SignalConnected(arg2,arg3);
57047     } CALL_CATCH_EXCEPTION();
57048   }
57049 }
57050
57051
57052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
57053   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
57054   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
57055   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
57056
57057   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
57058   arg2 = (Dali::SlotObserver *)jarg2;
57059   arg3 = (Dali::CallbackBase *)jarg3;
57060   {
57061     try {
57062       (arg1)->SignalDisconnected(arg2,arg3);
57063     } CALL_CATCH_EXCEPTION();
57064   }
57065 }
57066
57067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
57068   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
57069   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
57070   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
57071
57072   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
57073   arg2 = (Dali::SlotObserver *)jarg2;
57074   arg3 = (Dali::CallbackBase *)jarg3;
57075   {
57076     try {
57077       (arg1)->Dali::Internal::Adaptor::Widget::SignalDisconnected(arg2,arg3);
57078     } CALL_CATCH_EXCEPTION();
57079   }
57080 }
57081
57082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetContentInfo(void * jarg1, char * jarg2) {
57083   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
57084   std::string *arg2 = 0 ;
57085
57086   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
57087   if (!jarg2) {
57088     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57089     return ;
57090   }
57091   std::string arg2_str(jarg2);
57092   arg2 = &arg2_str;
57093   {
57094     try {
57095       (arg1)->SetContentInfo((std::string const &)*arg2);
57096     } CALL_CATCH_EXCEPTION();
57097   }
57098 }
57099
57100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetImpl(void * jarg1, void * jarg2) {
57101   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
57102   Dali::Internal::Adaptor::Widget::Impl *arg2 = (Dali::Internal::Adaptor::Widget::Impl *) 0 ;
57103
57104   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
57105   arg2 = (Dali::Internal::Adaptor::Widget::Impl *)jarg2;
57106   {
57107     try {
57108       (arg1)->SetImpl(arg2);
57109     } CALL_CATCH_EXCEPTION();
57110   }
57111 }
57112
57113
57114 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) {
57115   SwigDirector_WidgetImpl *director = static_cast<SwigDirector_WidgetImpl *>(objarg);
57116   if (director) {
57117     director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback7);
57118   }
57119 }
57120
57121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_GetImplementation__SWIG_0(void * jarg1) {
57122   void * jresult ;
57123   Dali::Widget *arg1 = 0 ;
57124   SwigDirector_WidgetImpl *result = 0 ;
57125
57126   arg1 = (Dali::Widget *)jarg1;
57127   if (!arg1) {
57128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget & type is null", 0);
57129     return 0;
57130   }
57131   {
57132     try {
57133       result = (SwigDirector_WidgetImpl *) &Dali::Internal::Adaptor::GetImplementation(*arg1);
57134     } CALL_CATCH_EXCEPTION(0);
57135   }
57136   jresult = (void*) result;
57137   return jresult;
57138 }
57139
57140
57141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_New(int jarg1, char * jarg2, char * jarg3) {
57142   void * jresult ;
57143   int *arg1 = (int *) 0 ;
57144   char ***arg2 ;
57145   std::string *arg3 = 0 ;
57146   Dali::WidgetApplication result;
57147   {
57148     int index = 0;
57149     int length = 0;
57150     char *retPtr;
57151     char *nextPtr;
57152     argWidgetC = jarg1;
57153     argWidgetV = new char*[jarg1 + 1];
57154
57155     retPtr = strtok_r( jarg2, " ", &nextPtr);
57156     if( retPtr )
57157     {
57158       length = strlen(retPtr);
57159     }
57160     argWidgetV[index] = new char[length + 1];
57161     if( retPtr )
57162     {
57163       strncpy(argWidgetV[index], retPtr, length);
57164     }
57165     argWidgetV[index][length] = '\0';
57166     index++;
57167
57168     while (index < jarg1)
57169     {
57170       length = 0;
57171       retPtr = strtok_r(NULL, " ", &nextPtr);
57172       if( retPtr )
57173       {
57174         length = strlen(retPtr);
57175       }
57176       argWidgetV[index] = new char[length + 1];
57177       if( retPtr )
57178       {
57179         strncpy(argWidgetV[index], retPtr, length);
57180       }
57181       argWidgetV[index][length] = '\0';
57182       index++;
57183     }
57184
57185     argWidgetV[jarg1] = NULL;
57186     argWidgetC = jarg1;
57187
57188     arg1 = &argWidgetC;
57189     arg2 = &argWidgetV;
57190   }
57191
57192   if (!jarg3) {
57193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57194     return 0;
57195   }
57196   std::string arg3_str(jarg3);
57197   arg3 = &arg3_str;
57198   {
57199     try {
57200       result = Dali::WidgetApplication::New(arg1,arg2,(std::string const &)*arg3);
57201     } CALL_CATCH_EXCEPTION(0);
57202   }
57203   jresult = new Dali::WidgetApplication((const Dali::WidgetApplication &)result);
57204   return jresult;
57205 }
57206
57207
57208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_0() {
57209   void * jresult ;
57210   Dali::WidgetApplication *result = 0 ;
57211
57212   {
57213     try {
57214       result = (Dali::WidgetApplication *)new Dali::WidgetApplication();
57215     } CALL_CATCH_EXCEPTION(0);
57216   }
57217   jresult = (void *)result;
57218   return jresult;
57219 }
57220
57221
57222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_1(void * jarg1) {
57223   void * jresult ;
57224   Dali::WidgetApplication *arg1 = 0 ;
57225   Dali::WidgetApplication *result = 0 ;
57226
57227   arg1 = (Dali::WidgetApplication *)jarg1;
57228   if (!arg1) {
57229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
57230     return 0;
57231   }
57232   {
57233     try {
57234       result = (Dali::WidgetApplication *)new Dali::WidgetApplication((Dali::WidgetApplication const &)*arg1);
57235     } CALL_CATCH_EXCEPTION(0);
57236   }
57237   jresult = (void *)result;
57238   return jresult;
57239 }
57240
57241
57242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_Assign(void * jarg1, void * jarg2) {
57243   void * jresult ;
57244   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
57245   Dali::WidgetApplication *arg2 = 0 ;
57246   Dali::WidgetApplication *result = 0 ;
57247
57248   arg1 = (Dali::WidgetApplication *)jarg1;
57249   arg2 = (Dali::WidgetApplication *)jarg2;
57250   if (!arg2) {
57251     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
57252     return 0;
57253   }
57254   {
57255     try {
57256       result = (Dali::WidgetApplication *) &(arg1)->operator =((Dali::WidgetApplication const &)*arg2);
57257     } CALL_CATCH_EXCEPTION(0);
57258   }
57259   jresult = (void *)result;
57260   return jresult;
57261 }
57262
57263
57264 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WidgetApplication(void * jarg1) {
57265   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
57266
57267   arg1 = (Dali::WidgetApplication *)jarg1;
57268   {
57269     try {
57270       delete arg1;
57271       if( argWidgetV )
57272       {
57273         // free string data
57274         for( int i=0; i < argWidgetC+1; i++)
57275         {
57276           delete [] argWidgetV[i];
57277         }
57278         delete [] argWidgetV;
57279       }
57280     } CALL_CATCH_EXCEPTION();
57281   }
57282 }
57283
57284
57285 typedef Dali::Widget*(SWIGSTDCALL *CSharpCreateWidgetFunction)(const std::string&);
57286 CSharpCreateWidgetFunction _CSharpCreateWidgetFunction = NULL;
57287
57288 static Dali::Widget SWIGSTDCALL WidgetFactoryFunction( const std::string& widgetName )
57289 {
57290   Widget* widget = _CSharpCreateWidgetFunction( widgetName.c_str() );
57291   return *widget;
57292 }
57293
57294 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetApplication_RegisterWidgetCreatingFunction(void * jarg1, char** jarg2, void * jarg3) {
57295   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
57296   std::string *arg2 = 0 ;
57297
57298   arg1 = (Dali::WidgetApplication *)jarg1;
57299   if (!jarg2) {
57300     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57301     return ;
57302   }
57303   std::string arg2_str(*jarg2);
57304   arg2 = &arg2_str;
57305
57306   if(!_CSharpCreateWidgetFunction)
57307   {
57308     _CSharpCreateWidgetFunction = (Dali::Widget*(*)(const std::string&))jarg3;
57309   }
57310
57311   {
57312     try {
57313       (arg1)->RegisterWidgetCreatingFunction((std::string const &)*arg2, WidgetFactoryFunction);
57314     } CALL_CATCH_EXCEPTION();
57315   }
57316   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
57317 }
57318
57319
57320 //for PixelBuffer and ImageLoading
57321
57322 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelBuffer_SWIGUpcast(Dali::Devel::PixelBuffer *jarg1) {
57323     return (Dali::BaseHandle *)jarg1;
57324 }
57325
57326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_New(unsigned int jarg1, unsigned int jarg2, int jarg3) {
57327   void * jresult ;
57328   unsigned int arg1 ;
57329   unsigned int arg2 ;
57330   Dali::Pixel::Format arg3 ;
57331   Dali::Devel::PixelBuffer result;
57332
57333   arg1 = (unsigned int)jarg1;
57334   arg2 = (unsigned int)jarg2;
57335   arg3 = (Dali::Pixel::Format)jarg3;
57336   {
57337     try {
57338       result = Dali::Devel::PixelBuffer::New(arg1,arg2,arg3);
57339     } CALL_CATCH_EXCEPTION(0);
57340   }
57341   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
57342   return jresult;
57343 }
57344
57345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_0() {
57346   void * jresult ;
57347   Dali::Devel::PixelBuffer *result = 0 ;
57348
57349   {
57350     try {
57351       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer();
57352     } CALL_CATCH_EXCEPTION(0);
57353   }
57354   jresult = (void *)result;
57355   return jresult;
57356 }
57357
57358
57359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelBuffer(void * jarg1) {
57360   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
57361
57362   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57363   {
57364     try {
57365       delete arg1;
57366     } CALL_CATCH_EXCEPTION();
57367   }
57368 }
57369
57370
57371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_1(void * jarg1) {
57372   void * jresult ;
57373   Dali::Devel::PixelBuffer *arg1 = 0 ;
57374   Dali::Devel::PixelBuffer *result = 0 ;
57375
57376   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57377   if (!arg1) {
57378     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
57379     return 0;
57380   }
57381   {
57382     try {
57383       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer((Dali::Devel::PixelBuffer const &)*arg1);
57384     } CALL_CATCH_EXCEPTION(0);
57385   }
57386   jresult = (void *)result;
57387   return jresult;
57388 }
57389
57390
57391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Assign(void * jarg1, void * jarg2) {
57392   void * jresult ;
57393   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
57394   Dali::Devel::PixelBuffer *arg2 = 0 ;
57395   Dali::Devel::PixelBuffer *result = 0 ;
57396
57397   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57398   arg2 = (Dali::Devel::PixelBuffer *)jarg2;
57399   if (!arg2) {
57400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
57401     return 0;
57402   }
57403   {
57404     try {
57405       result = (Dali::Devel::PixelBuffer *) &(arg1)->operator =((Dali::Devel::PixelBuffer const &)*arg2);
57406     } CALL_CATCH_EXCEPTION(0);
57407   }
57408   jresult = (void *)result;
57409   return jresult;
57410 }
57411
57412
57413 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Convert(void * jarg1) {
57414   void * jresult ;
57415   Dali::Devel::PixelBuffer *arg1 = 0 ;
57416   Dali::PixelData result;
57417
57418   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57419   if (!arg1) {
57420     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer & type is null", 0);
57421     return 0;
57422   }
57423   {
57424     try {
57425       result = Dali::Devel::PixelBuffer::Convert(*arg1);
57426     } CALL_CATCH_EXCEPTION(0);
57427   }
57428   jresult = new Dali::PixelData((const Dali::PixelData &)result);
57429   return jresult;
57430 }
57431
57432
57433 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_CreatePixelData(void * jarg1) {
57434   void * jresult ;
57435   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
57436   Dali::PixelData result;
57437
57438   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57439   {
57440     try {
57441       result = ((Dali::Devel::PixelBuffer const *)arg1)->CreatePixelData();
57442     } CALL_CATCH_EXCEPTION(0);
57443   }
57444   jresult = new Dali::PixelData((const Dali::PixelData &)result);
57445   return jresult;
57446 }
57447
57448
57449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_GetBuffer(void * jarg1) {
57450   void * jresult ;
57451   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
57452   unsigned char *result = 0 ;
57453
57454   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57455   {
57456     try {
57457       result = (unsigned char *)(arg1)->GetBuffer();
57458     } CALL_CATCH_EXCEPTION(0);
57459   }
57460    jresult = (void *)result;
57461    return jresult;
57462 }
57463
57464 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetWidth(void * jarg1) {
57465   unsigned int jresult ;
57466   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
57467   unsigned int result;
57468
57469   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57470   {
57471     try {
57472       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetWidth();
57473     } CALL_CATCH_EXCEPTION(0);
57474   }
57475   jresult = result;
57476   return jresult;
57477 }
57478
57479
57480 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetHeight(void * jarg1) {
57481   unsigned int jresult ;
57482   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
57483   unsigned int result;
57484
57485   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57486   {
57487     try {
57488       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetHeight();
57489     } CALL_CATCH_EXCEPTION(0);
57490   }
57491   jresult = result;
57492   return jresult;
57493 }
57494
57495
57496 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetPixelFormat(void * jarg1) {
57497   int jresult ;
57498   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
57499   Dali::Pixel::Format result;
57500
57501   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57502   {
57503     try {
57504       result = (Dali::Pixel::Format)((Dali::Devel::PixelBuffer const *)arg1)->GetPixelFormat();
57505     } CALL_CATCH_EXCEPTION(0);
57506   }
57507   jresult = (int)result;
57508   return jresult;
57509 }
57510
57511
57512 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_0(void * jarg1, void * jarg2, float jarg3, unsigned int jarg4) {
57513   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
57514   Dali::Devel::PixelBuffer arg2 ;
57515   float arg3 ;
57516   bool arg4 ;
57517   Dali::Devel::PixelBuffer *argp2 ;
57518
57519   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57520   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
57521   if (!argp2) {
57522     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
57523     return ;
57524   }
57525   arg2 = *argp2;
57526   arg3 = (float)jarg3;
57527   arg4 = jarg4 ? true : false;
57528   {
57529     try {
57530       (arg1)->ApplyMask(arg2,arg3,arg4);
57531     } CALL_CATCH_EXCEPTION();
57532   }
57533 }
57534
57535
57536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
57537   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
57538   Dali::Devel::PixelBuffer arg2 ;
57539   float arg3 ;
57540   Dali::Devel::PixelBuffer *argp2 ;
57541
57542   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57543   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
57544   if (!argp2) {
57545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
57546     return ;
57547   }
57548   arg2 = *argp2;
57549   arg3 = (float)jarg3;
57550   {
57551     try {
57552       (arg1)->ApplyMask(arg2,arg3);
57553     } CALL_CATCH_EXCEPTION();
57554   }
57555 }
57556
57557
57558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_2(void * jarg1, void * jarg2) {
57559   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
57560   Dali::Devel::PixelBuffer arg2 ;
57561   Dali::Devel::PixelBuffer *argp2 ;
57562
57563   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57564   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
57565   if (!argp2) {
57566     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
57567     return ;
57568   }
57569   arg2 = *argp2;
57570   {
57571     try {
57572       (arg1)->ApplyMask(arg2);
57573     } CALL_CATCH_EXCEPTION();
57574   }
57575 }
57576
57577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyGaussianBlur(void * jarg1, float jarg2) {
57578   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
57579   float arg2 ;
57580
57581   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57582   arg2 = (float)jarg2;
57583   {
57584     try {
57585       (arg1)->ApplyGaussianBlur(arg2);
57586     } CALL_CATCH_EXCEPTION();
57587   }
57588 }
57589
57590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Crop(void * jarg1, unsigned short jarg2, unsigned short jarg3, unsigned short jarg4, unsigned short jarg5) {
57591   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
57592   uint16_t arg2 ;
57593   uint16_t arg3 ;
57594   uint16_t arg4 ;
57595   uint16_t arg5 ;
57596
57597   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57598   arg2 = (uint16_t)jarg2;
57599   arg3 = (uint16_t)jarg3;
57600   arg4 = (uint16_t)jarg4;
57601   arg5 = (uint16_t)jarg5;
57602   {
57603     try {
57604       (arg1)->Crop(arg2,arg3,arg4,arg5);
57605     } CALL_CATCH_EXCEPTION();
57606   }
57607 }
57608
57609
57610 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Resize(void * jarg1, unsigned short jarg2, unsigned short jarg3) {
57611   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
57612   uint16_t arg2 ;
57613   uint16_t arg3 ;
57614
57615   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57616   arg2 = (uint16_t)jarg2;
57617   arg3 = (uint16_t)jarg3;
57618   {
57619     try {
57620       (arg1)->Resize(arg2,arg3);
57621     } CALL_CATCH_EXCEPTION();
57622   }
57623 }
57624
57625 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PixelBuffer_Rotate(void * jarg1, void* jarg2) {
57626   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
57627   Dali::Degree * arg2 ;
57628
57629   bool result = false;
57630
57631   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57632   arg2 = (Dali::Degree *)jarg2;
57633   {
57634     try {
57635       result = (arg1)->Rotate(*arg2);
57636     } CALL_CATCH_EXCEPTION(false);
57637   }
57638   return result;
57639 }
57640
57641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
57642   void * jresult ;
57643   std::string *arg1 = 0 ;
57644   Dali::ImageDimensions arg2 ;
57645   Dali::FittingMode::Type arg3 ;
57646   Dali::SamplingMode::Type arg4 ;
57647   bool arg5 ;
57648   Dali::ImageDimensions *argp2 ;
57649   Dali::Devel::PixelBuffer result;
57650
57651   if (!jarg1) {
57652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57653     return 0;
57654   }
57655   std::string arg1_str(jarg1);
57656   arg1 = &arg1_str;
57657   argp2 = (Dali::ImageDimensions *)jarg2;
57658   if (!argp2) {
57659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
57660     return 0;
57661   }
57662   arg2 = *argp2;
57663   arg3 = (Dali::FittingMode::Type)jarg3;
57664   arg4 = (Dali::SamplingMode::Type)jarg4;
57665   arg5 = jarg5 ? true : false;
57666   {
57667     try {
57668       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4,arg5);
57669     } CALL_CATCH_EXCEPTION(0);
57670   }
57671   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
57672   return jresult;
57673 }
57674
57675
57676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
57677   void * jresult ;
57678   std::string *arg1 = 0 ;
57679   Dali::ImageDimensions arg2 ;
57680   Dali::FittingMode::Type arg3 ;
57681   Dali::SamplingMode::Type arg4 ;
57682   Dali::ImageDimensions *argp2 ;
57683   Dali::Devel::PixelBuffer result;
57684
57685   if (!jarg1) {
57686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57687     return 0;
57688   }
57689   std::string arg1_str(jarg1);
57690   arg1 = &arg1_str;
57691   argp2 = (Dali::ImageDimensions *)jarg2;
57692   if (!argp2) {
57693     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
57694     return 0;
57695   }
57696   arg2 = *argp2;
57697   arg3 = (Dali::FittingMode::Type)jarg3;
57698   arg4 = (Dali::SamplingMode::Type)jarg4;
57699   {
57700     try {
57701       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4);
57702     } CALL_CATCH_EXCEPTION(0);
57703   }
57704   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
57705   return jresult;
57706 }
57707
57708
57709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
57710   void * jresult ;
57711   std::string *arg1 = 0 ;
57712   Dali::ImageDimensions arg2 ;
57713   Dali::FittingMode::Type arg3 ;
57714   Dali::ImageDimensions *argp2 ;
57715   Dali::Devel::PixelBuffer result;
57716
57717   if (!jarg1) {
57718     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57719     return 0;
57720   }
57721   std::string arg1_str(jarg1);
57722   arg1 = &arg1_str;
57723   argp2 = (Dali::ImageDimensions *)jarg2;
57724   if (!argp2) {
57725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
57726     return 0;
57727   }
57728   arg2 = *argp2;
57729   arg3 = (Dali::FittingMode::Type)jarg3;
57730   {
57731     try {
57732       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3);
57733     } CALL_CATCH_EXCEPTION(0);
57734   }
57735   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
57736   return jresult;
57737 }
57738
57739
57740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_3(char * jarg1, void * jarg2) {
57741   void * jresult ;
57742   std::string *arg1 = 0 ;
57743   Dali::ImageDimensions arg2 ;
57744   Dali::ImageDimensions *argp2 ;
57745   Dali::Devel::PixelBuffer result;
57746
57747   if (!jarg1) {
57748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57749     return 0;
57750   }
57751   std::string arg1_str(jarg1);
57752   arg1 = &arg1_str;
57753   argp2 = (Dali::ImageDimensions *)jarg2;
57754   if (!argp2) {
57755     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
57756     return 0;
57757   }
57758   arg2 = *argp2;
57759   {
57760     try {
57761       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2);
57762     } CALL_CATCH_EXCEPTION(0);
57763   }
57764   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
57765   return jresult;
57766 }
57767
57768
57769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_4(char * jarg1) {
57770   void * jresult ;
57771   std::string *arg1 = 0 ;
57772   Dali::Devel::PixelBuffer result;
57773
57774   if (!jarg1) {
57775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57776     return 0;
57777   }
57778   std::string arg1_str(jarg1);
57779   arg1 = &arg1_str;
57780   {
57781     try {
57782       result = Dali::LoadImageFromFile((std::string const &)*arg1);
57783     } CALL_CATCH_EXCEPTION(0);
57784   }
57785   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
57786   return jresult;
57787 }
57788
57789
57790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
57791   void * jresult ;
57792   std::string *arg1 = 0 ;
57793   Dali::ImageDimensions arg2 ;
57794   Dali::FittingMode::Type arg3 ;
57795   Dali::SamplingMode::Type arg4 ;
57796   bool arg5 ;
57797   Dali::ImageDimensions *argp2 ;
57798   Dali::ImageDimensions result;
57799
57800   if (!jarg1) {
57801     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57802     return 0;
57803   }
57804   std::string arg1_str(jarg1);
57805   arg1 = &arg1_str;
57806   argp2 = (Dali::ImageDimensions *)jarg2;
57807   if (!argp2) {
57808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
57809     return 0;
57810   }
57811   arg2 = *argp2;
57812   arg3 = (Dali::FittingMode::Type)jarg3;
57813   arg4 = (Dali::SamplingMode::Type)jarg4;
57814   arg5 = jarg5 ? true : false;
57815   {
57816     try {
57817       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4,arg5);
57818     } CALL_CATCH_EXCEPTION(0);
57819   }
57820   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
57821   return jresult;
57822 }
57823
57824
57825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
57826   void * jresult ;
57827   std::string *arg1 = 0 ;
57828   Dali::ImageDimensions arg2 ;
57829   Dali::FittingMode::Type arg3 ;
57830   Dali::SamplingMode::Type arg4 ;
57831   Dali::ImageDimensions *argp2 ;
57832   Dali::ImageDimensions result;
57833
57834   if (!jarg1) {
57835     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57836     return 0;
57837   }
57838   std::string arg1_str(jarg1);
57839   arg1 = &arg1_str;
57840   argp2 = (Dali::ImageDimensions *)jarg2;
57841   if (!argp2) {
57842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
57843     return 0;
57844   }
57845   arg2 = *argp2;
57846   arg3 = (Dali::FittingMode::Type)jarg3;
57847   arg4 = (Dali::SamplingMode::Type)jarg4;
57848   {
57849     try {
57850       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4);
57851     } CALL_CATCH_EXCEPTION(0);
57852   }
57853   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
57854   return jresult;
57855 }
57856
57857
57858 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
57859   void * jresult ;
57860   std::string *arg1 = 0 ;
57861   Dali::ImageDimensions arg2 ;
57862   Dali::FittingMode::Type arg3 ;
57863   Dali::ImageDimensions *argp2 ;
57864   Dali::ImageDimensions result;
57865
57866   if (!jarg1) {
57867     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57868     return 0;
57869   }
57870   std::string arg1_str(jarg1);
57871   arg1 = &arg1_str;
57872   argp2 = (Dali::ImageDimensions *)jarg2;
57873   if (!argp2) {
57874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
57875     return 0;
57876   }
57877   arg2 = *argp2;
57878   arg3 = (Dali::FittingMode::Type)jarg3;
57879   {
57880     try {
57881       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3);
57882     } CALL_CATCH_EXCEPTION(0);
57883   }
57884   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
57885   return jresult;
57886 }
57887
57888
57889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_3(char * jarg1, void * jarg2) {
57890   void * jresult ;
57891   std::string *arg1 = 0 ;
57892   Dali::ImageDimensions arg2 ;
57893   Dali::ImageDimensions *argp2 ;
57894   Dali::ImageDimensions result;
57895
57896   if (!jarg1) {
57897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57898     return 0;
57899   }
57900   std::string arg1_str(jarg1);
57901   arg1 = &arg1_str;
57902   argp2 = (Dali::ImageDimensions *)jarg2;
57903   if (!argp2) {
57904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
57905     return 0;
57906   }
57907   arg2 = *argp2;
57908   {
57909     try {
57910       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2);
57911     } CALL_CATCH_EXCEPTION(0);
57912   }
57913   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
57914   return jresult;
57915 }
57916
57917
57918 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_4(char * jarg1) {
57919   void * jresult ;
57920   std::string *arg1 = 0 ;
57921   Dali::ImageDimensions result;
57922
57923   if (!jarg1) {
57924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57925     return 0;
57926   }
57927   std::string arg1_str(jarg1);
57928   arg1 = &arg1_str;
57929   {
57930     try {
57931       result = Dali::GetClosestImageSize((std::string const &)*arg1);
57932     } CALL_CATCH_EXCEPTION(0);
57933   }
57934   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
57935   return jresult;
57936 }
57937
57938 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetOriginalImageSize(char * jarg1) {
57939   void * jresult ;
57940   std::string *arg1 = 0 ;
57941   Dali::ImageDimensions result;
57942
57943   if (!jarg1) {
57944     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57945     return 0;
57946   }
57947   std::string arg1_str(jarg1);
57948   arg1 = &arg1_str;
57949   {
57950     try {
57951       result = Dali::GetOriginalImageSize((std::string const &)*arg1);
57952     } CALL_CATCH_EXCEPTION(0);
57953   }
57954   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
57955   return jresult;
57956 }
57957
57958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
57959   void * jresult ;
57960   std::string *arg1 = 0 ;
57961   Dali::ImageDimensions arg2 ;
57962   Dali::FittingMode::Type arg3 ;
57963   Dali::SamplingMode::Type arg4 ;
57964   bool arg5 ;
57965   Dali::ImageDimensions *argp2 ;
57966   Dali::Devel::PixelBuffer result;
57967
57968   if (!jarg1) {
57969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57970     return 0;
57971   }
57972   std::string arg1_str(jarg1);
57973   arg1 = &arg1_str;
57974   argp2 = (Dali::ImageDimensions *)jarg2;
57975   if (!argp2) {
57976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
57977     return 0;
57978   }
57979   arg2 = *argp2;
57980   arg3 = (Dali::FittingMode::Type)jarg3;
57981   arg4 = (Dali::SamplingMode::Type)jarg4;
57982   arg5 = jarg5 ? true : false;
57983   {
57984     try {
57985       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4,arg5);
57986     } CALL_CATCH_EXCEPTION(0);
57987   }
57988   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
57989   return jresult;
57990 }
57991
57992
57993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
57994   void * jresult ;
57995   std::string *arg1 = 0 ;
57996   Dali::ImageDimensions arg2 ;
57997   Dali::FittingMode::Type arg3 ;
57998   Dali::SamplingMode::Type arg4 ;
57999   Dali::ImageDimensions *argp2 ;
58000   Dali::Devel::PixelBuffer result;
58001
58002   if (!jarg1) {
58003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58004     return 0;
58005   }
58006   std::string arg1_str(jarg1);
58007   arg1 = &arg1_str;
58008   argp2 = (Dali::ImageDimensions *)jarg2;
58009   if (!argp2) {
58010     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
58011     return 0;
58012   }
58013   arg2 = *argp2;
58014   arg3 = (Dali::FittingMode::Type)jarg3;
58015   arg4 = (Dali::SamplingMode::Type)jarg4;
58016   {
58017     try {
58018       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4);
58019     } CALL_CATCH_EXCEPTION(0);
58020   }
58021   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
58022   return jresult;
58023 }
58024
58025
58026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
58027   void * jresult ;
58028   std::string *arg1 = 0 ;
58029   Dali::ImageDimensions arg2 ;
58030   Dali::FittingMode::Type arg3 ;
58031   Dali::ImageDimensions *argp2 ;
58032   Dali::Devel::PixelBuffer result;
58033
58034   if (!jarg1) {
58035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58036     return 0;
58037   }
58038   std::string arg1_str(jarg1);
58039   arg1 = &arg1_str;
58040   argp2 = (Dali::ImageDimensions *)jarg2;
58041   if (!argp2) {
58042     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
58043     return 0;
58044   }
58045   arg2 = *argp2;
58046   arg3 = (Dali::FittingMode::Type)jarg3;
58047   {
58048     try {
58049       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3);
58050     } CALL_CATCH_EXCEPTION(0);
58051   }
58052   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
58053   return jresult;
58054 }
58055
58056
58057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_3(char * jarg1, void * jarg2) {
58058   void * jresult ;
58059   std::string *arg1 = 0 ;
58060   Dali::ImageDimensions arg2 ;
58061   Dali::ImageDimensions *argp2 ;
58062   Dali::Devel::PixelBuffer result;
58063
58064   if (!jarg1) {
58065     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58066     return 0;
58067   }
58068   std::string arg1_str(jarg1);
58069   arg1 = &arg1_str;
58070   argp2 = (Dali::ImageDimensions *)jarg2;
58071   if (!argp2) {
58072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
58073     return 0;
58074   }
58075   arg2 = *argp2;
58076   {
58077     try {
58078       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2);
58079     } CALL_CATCH_EXCEPTION(0);
58080   }
58081   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
58082   return jresult;
58083 }
58084
58085
58086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_4(char * jarg1) {
58087   void * jresult ;
58088   std::string *arg1 = 0 ;
58089   Dali::Devel::PixelBuffer result;
58090
58091   if (!jarg1) {
58092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58093     return 0;
58094   }
58095   std::string arg1_str(jarg1);
58096   arg1 = &arg1_str;
58097   {
58098     try {
58099       result = Dali::DownloadImageSynchronously((std::string const &)*arg1);
58100     } CALL_CATCH_EXCEPTION(0);
58101   }
58102   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
58103   return jresult;
58104 }
58105
58106
58107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New() {
58108   void * jresult ;
58109   Dali::Toolkit::WebView result;
58110
58111   {
58112     try {
58113       result = Dali::Toolkit::WebView::New();
58114     } CALL_CATCH_EXCEPTION(0);
58115   }
58116   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
58117   return jresult;
58118 }
58119
58120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New_2(char * jarg1, char * jarg2) {
58121   void * jresult ;
58122   Dali::Toolkit::WebView result;
58123
58124   std::string *arg1;
58125   std::string *arg2;
58126
58127   if (!jarg1) {
58128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg1 is null string", 0);
58129     return 0;
58130   }
58131   if (!jarg2) {
58132     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg2 is null string", 0);
58133     return 0;
58134   }
58135
58136   std::string jarg1_str = std::string(jarg1);
58137   std::string jarg2_str = std::string(jarg2);
58138
58139   arg1 = &jarg1_str;
58140   arg2 = &jarg2_str;
58141
58142   {
58143     try {
58144       result = Dali::Toolkit::WebView::New( (std::string const &)*arg1, (std::string const &)*arg2);
58145     } CALL_CATCH_EXCEPTION(0);
58146   }
58147   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
58148   return jresult;
58149 }
58150
58151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebView__SWIG_1(void * jarg1) {
58152   void * jresult ;
58153   Dali::Toolkit::WebView *arg1 = 0 ;
58154   Dali::Toolkit::WebView *result = 0 ;
58155
58156   arg1 = (Dali::Toolkit::WebView *)jarg1;
58157   if (!arg1) {
58158     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
58159     return 0;
58160   }
58161   {
58162     try {
58163       result = (Dali::Toolkit::WebView *)new Dali::Toolkit::WebView((Dali::Toolkit::WebView const &)*arg1);
58164     } CALL_CATCH_EXCEPTION(0);
58165   }
58166   jresult = (void *)result;
58167   return jresult;
58168 }
58169
58170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebView(void * jarg1) {
58171   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58172   arg1 = (Dali::Toolkit::WebView *)jarg1;
58173   {
58174     try {
58175       delete arg1;
58176     } CALL_CATCH_EXCEPTION();
58177   }
58178 }
58179
58180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_Assign(void * jarg1, void * jarg2) {
58181   void * jresult ;
58182   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58183   Dali::Toolkit::WebView *arg2 = 0 ;
58184   Dali::Toolkit::WebView *result = 0 ;
58185
58186   arg1 = (Dali::Toolkit::WebView *)jarg1;
58187   arg2 = (Dali::Toolkit::WebView *)jarg2;
58188   if (!arg2) {
58189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
58190     return 0;
58191   }
58192   {
58193     try {
58194       result = (Dali::Toolkit::WebView *) &(arg1)->operator =((Dali::Toolkit::WebView const &)*arg2);
58195     } CALL_CATCH_EXCEPTION(0);
58196   }
58197   jresult = (void *)result;
58198   return jresult;
58199 }
58200
58201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_DownCast(void * jarg1) {
58202   void * jresult ;
58203   Dali::BaseHandle arg1 ;
58204   Dali::BaseHandle *argp1 ;
58205   Dali::Toolkit::WebView result;
58206
58207   argp1 = (Dali::BaseHandle *)jarg1;
58208   if (!argp1) {
58209     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
58210     return 0;
58211   }
58212   arg1 = *argp1;
58213   {
58214     try {
58215       result = Dali::Toolkit::WebView::DownCast(arg1);
58216     } CALL_CATCH_EXCEPTION(0);
58217   }
58218   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
58219   return jresult;
58220 }
58221
58222 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_URL_get() {
58223   return (int) Dali::Toolkit::WebView::Property::URL;
58224 }
58225
58226 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_CACHE_MODEL_get() {
58227   return (int) Dali::Toolkit::WebView::Property::CACHE_MODEL;
58228 }
58229
58230 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_COOKIE_ACCEPT_POLICY_get() {
58231   return (int) Dali::Toolkit::WebView::Property::COOKIE_ACCEPT_POLICY;
58232 }
58233
58234 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_USER_AGENT_get() {
58235   return (int) Dali::Toolkit::WebView::Property::USER_AGENT;
58236 }
58237
58238 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_ENABLE_JAVASCRIPT_get() {
58239   return (int) Dali::Toolkit::WebView::Property::ENABLE_JAVASCRIPT;
58240 }
58241
58242 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_LOAD_IMAGES_AUTOMATICALLY_get() {
58243   return (int) Dali::Toolkit::WebView::Property::LOAD_IMAGES_AUTOMATICALLY;
58244 }
58245
58246 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_DEFAULT_TEXT_ENCODING_NAME_get() {
58247   return (int) Dali::Toolkit::WebView::Property::DEFAULT_TEXT_ENCODING_NAME;
58248 }
58249
58250 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_DEFAULT_FONT_SIZE_get() {
58251   return (int) Dali::Toolkit::WebView::Property::DEFAULT_FONT_SIZE;
58252 }
58253
58254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadUrl(void * jarg1, char * jarg2) {
58255   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58256   std::string *arg2;
58257
58258   arg1 = (Dali::Toolkit::WebView *)jarg1;
58259
58260   if (!jarg2) {
58261     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58262     return;
58263   }
58264
58265   std::string jarg2str = std::string(jarg2);
58266   arg2 = &jarg2str;
58267   {
58268     try {
58269       (arg1)->LoadUrl((std::string const &)*arg2);
58270     } CALL_CATCH_EXCEPTION();
58271   }
58272 }
58273
58274 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadHTMLString(void * jarg1, char * jarg2) {
58275   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58276   std::string *arg2;
58277
58278   arg1 = (Dali::Toolkit::WebView *)jarg1;
58279   if (!jarg2) {
58280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58281     return;
58282   }
58283   std::string jarg2str = std::string(jarg2);
58284   arg2 = &jarg2str;
58285   {
58286     try {
58287       (arg1)->LoadHTMLString((std::string const &)*arg2);
58288     } CALL_CATCH_EXCEPTION();
58289   }
58290 }
58291
58292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Reload(void * jarg1) {
58293   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58294
58295   arg1 = (Dali::Toolkit::WebView *)jarg1;
58296   {
58297     try {
58298       (arg1)->Reload();
58299     } CALL_CATCH_EXCEPTION();
58300   }
58301 }
58302
58303 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_StopLoading(void * jarg1) {
58304   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58305
58306   arg1 = (Dali::Toolkit::WebView *)jarg1;
58307   {
58308     try {
58309       (arg1)->StopLoading();
58310     } CALL_CATCH_EXCEPTION();
58311   }
58312 }
58313
58314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Suspend(void * jarg1) {
58315   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58316
58317   arg1 = (Dali::Toolkit::WebView *)jarg1;
58318   {
58319     try {
58320       (arg1)->Suspend();
58321     } CALL_CATCH_EXCEPTION();
58322   }
58323 }
58324
58325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Resume(void * jarg1) {
58326   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58327
58328   arg1 = (Dali::Toolkit::WebView *)jarg1;
58329   {
58330     try {
58331       (arg1)->Resume();
58332     } CALL_CATCH_EXCEPTION();
58333   }
58334 }
58335
58336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoBack(void * jarg1) {
58337   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58338
58339   arg1 = (Dali::Toolkit::WebView *)jarg1;
58340   {
58341     try {
58342       (arg1)->GoBack();
58343     } CALL_CATCH_EXCEPTION();
58344   }
58345 }
58346
58347 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoForward(void * jarg1) {
58348   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58349
58350   arg1 = (Dali::Toolkit::WebView *)jarg1;
58351   {
58352     try {
58353       (arg1)->GoForward();
58354     } CALL_CATCH_EXCEPTION();
58355   }
58356 }
58357
58358 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoBack(void * jarg1) {
58359   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58360   bool ret;
58361
58362   arg1 = (Dali::Toolkit::WebView *)jarg1;
58363   {
58364     try {
58365       ret = (arg1)->CanGoBack();
58366     } CALL_CATCH_EXCEPTION(0);
58367   }
58368   return ret;
58369 }
58370
58371 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoForward(void * jarg1) {
58372   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58373   bool ret;
58374
58375   arg1 = (Dali::Toolkit::WebView *)jarg1;
58376   {
58377     try {
58378       ret = (arg1)->CanGoForward();
58379     } CALL_CATCH_EXCEPTION(0);
58380   }
58381   return ret;
58382 }
58383
58384 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_EvaluateJavaScript(void * jarg1, char * jarg2, void* jarg3) {
58385   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58386   std::string *arg2;
58387
58388   arg1 = (Dali::Toolkit::WebView *)jarg1;
58389   if (!jarg2) {
58390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58391     return;
58392   }
58393   std::string jarg2_str = std::string(jarg2);
58394   arg2 = &jarg2_str;
58395
58396   {
58397     try {
58398       if (jarg3) {
58399         void (*handler)(char*) = (void (*)(char*)) jarg3;
58400         (arg1)->EvaluateJavaScript((std::string const &)*arg2, [handler](const std::string& result) {
58401           handler(SWIG_csharp_string_callback(result.c_str()));
58402         });
58403       } else {
58404         (arg1)->EvaluateJavaScript((std::string const &)*arg2);
58405       }
58406     } CALL_CATCH_EXCEPTION();
58407   }
58408 }
58409
58410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_AddJavaScriptMessageHandler(void* jarg1, char* jarg2, void* jarg3)
58411 {
58412   if (!jarg2) {
58413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58414     return;
58415   }
58416
58417   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
58418   std::string exposedObjectName = jarg2;
58419   void (*handler)(char*) = (void (*)(char*)) jarg3;
58420
58421   {
58422     try {
58423       webview->AddJavaScriptMessageHandler(exposedObjectName, [handler](const std::string& message) {
58424         handler(SWIG_csharp_string_callback(message.c_str()));
58425       });
58426     } CALL_CATCH_EXCEPTION();
58427   }
58428 }
58429
58430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearHistory(void * jarg1) {
58431   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58432
58433   arg1 = (Dali::Toolkit::WebView *)jarg1;
58434   {
58435     try {
58436       (arg1)->ClearHistory();
58437     } CALL_CATCH_EXCEPTION();
58438   }
58439 }
58440
58441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearCache(void * jarg1) {
58442   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58443
58444   arg1 = (Dali::Toolkit::WebView *)jarg1;
58445   {
58446     try {
58447       (arg1)->ClearCache();
58448     } CALL_CATCH_EXCEPTION();
58449   }
58450 }
58451
58452 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearCookies(void * jarg1) {
58453   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58454
58455   arg1 = (Dali::Toolkit::WebView *)jarg1;
58456   {
58457     try {
58458       (arg1)->ClearCookies();
58459     } CALL_CATCH_EXCEPTION();
58460   }
58461 }
58462
58463 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_WebView_SWIGUpcast(Dali::Toolkit::WebView *jarg1) {
58464     return (Dali::Toolkit::Control *)jarg1;
58465 }
58466
58467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadSignal_PageLoadStarted(void * jarg1) {
58468   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
58469   SignalConverter::WebViewPageLoadSignal* result = NULL;
58470   {
58471     try {
58472       result = new SignalConverter::WebViewPageLoadSignal(&webview->PageLoadStartedSignal());
58473     } CALL_CATCH_EXCEPTION(0);
58474   }
58475   return (void*) result;
58476 }
58477
58478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadSignal_PageLoadFinished(void * jarg1) {
58479   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
58480   SignalConverter::WebViewPageLoadSignal* result = NULL;
58481   {
58482     try {
58483       result = new SignalConverter::WebViewPageLoadSignal(&webview->PageLoadFinishedSignal());
58484     } CALL_CATCH_EXCEPTION(0);
58485   }
58486   return (void*) result;
58487 }
58488
58489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewPageLoadSignal(void * jarg1)
58490 {
58491   SignalConverter::WebViewPageLoadSignal* object = (SignalConverter::WebViewPageLoadSignal*) jarg1;
58492   {
58493     try {
58494       delete object;
58495     } CALL_CATCH_EXCEPTION();
58496   }
58497 }
58498
58499 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadSignal_Connect(void * jarg1, void * jarg2)
58500 {
58501   SignalConverter::WebViewPageLoadSignal* proxy = (SignalConverter::WebViewPageLoadSignal*) jarg1;
58502   SignalConverter::WebViewPageLoadSignal::CallbackType callback = (SignalConverter::WebViewPageLoadSignal::CallbackType) jarg2;
58503   {
58504     try {
58505       proxy->Connect(callback);
58506     } CALL_CATCH_EXCEPTION();
58507   }
58508 }
58509
58510
58511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadSignal_Disconnect(void * jarg1, void * jarg2) {
58512   SignalConverter::WebViewPageLoadSignal* proxy = (SignalConverter::WebViewPageLoadSignal*) jarg1;
58513   SignalConverter::WebViewPageLoadSignal::CallbackType callback = (SignalConverter::WebViewPageLoadSignal::CallbackType) jarg2;
58514   {
58515     try {
58516       proxy->Disconnect(callback);
58517     } CALL_CATCH_EXCEPTION();
58518   }
58519 }
58520
58521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadErrorSignal_PageLoadError(void * jarg1) {
58522   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
58523   SignalConverter::WebViewPageLoadErrorSignal* result = NULL;
58524   {
58525     try {
58526       result = new SignalConverter::WebViewPageLoadErrorSignal(&webview->PageLoadErrorSignal());
58527     } CALL_CATCH_EXCEPTION(0);
58528   }
58529   return (void*) result;
58530 }
58531
58532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewPageLoadErrorSignal(void * jarg1)
58533 {
58534   SignalConverter::WebViewPageLoadErrorSignal* object = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
58535   {
58536     try {
58537       delete object;
58538     } CALL_CATCH_EXCEPTION();
58539   }
58540 }
58541
58542 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadErrorSignal_Connect(void * jarg1, void * jarg2)
58543 {
58544   SignalConverter::WebViewPageLoadErrorSignal* proxy = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
58545   SignalConverter::WebViewPageLoadErrorSignal::CallbackType callback = (SignalConverter::WebViewPageLoadErrorSignal::CallbackType) jarg2;
58546   {
58547     try {
58548       proxy->Connect(callback);
58549     } CALL_CATCH_EXCEPTION();
58550   }
58551 }
58552
58553
58554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadErrorSignal_Disconnect(void * jarg1, void * jarg2) {
58555   SignalConverter::WebViewPageLoadErrorSignal* proxy = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
58556   SignalConverter::WebViewPageLoadErrorSignal::CallbackType callback = (SignalConverter::WebViewPageLoadErrorSignal::CallbackType) jarg2;
58557   {
58558     try {
58559       proxy->Disconnect(callback);
58560     } CALL_CATCH_EXCEPTION();
58561   }
58562 }
58563
58564 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetEnvironmentVariable(char * jarg1) {
58565   const char * result = EnvironmentVariable::GetEnvironmentVariable(jarg1);
58566   char * jresult = SWIG_csharp_string_callback((const char *)result);
58567   return jresult;
58568 }
58569
58570 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_SetEnvironmentVariable(char * jarg1, char * jarg2) {
58571   bool result = EnvironmentVariable::SetEnvironmentVariable(jarg1, jarg2);
58572   return result;
58573 }
58574
58575
58576 struct NativeImageSourcePtrHandle
58577 {
58578   NativeImageSourcePtr Ptr;
58579 };
58580
58581 SWIGEXPORT NativeImageInterface* SWIGSTDCALL CSharp_Dali_NativeImageSource_Upcast(void* jarg1)
58582 {
58583   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
58584   return (NativeImageInterface*)(arg1);
58585 }
58586
58587 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_New_Handle(unsigned int jarg1, unsigned int jarg2, int jarg3)
58588 {
58589   void* jresult;
58590   NativeImageSourcePtrHandle* handle = new NativeImageSourcePtrHandle();
58591   {
58592     try {
58593       handle->Ptr = ( NativeImageSource::New(jarg1, jarg2, (NativeImageSource::ColorDepth)jarg3) );
58594     }
58595     catch (std::out_of_range & e) {
58596       {
58597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58598       };
58599     }
58600     catch (std::exception & e) {
58601       {
58602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58603       };
58604     }
58605     catch (Dali::DaliException e) {
58606       {
58607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58608       };
58609     }
58610     catch (...) {
58611       {
58612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58613       };
58614     }
58615   }
58616   jresult = (void *)handle;
58617   return jresult;
58618 }
58619
58620 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_New(void* jarg1)
58621 {
58622   void* jresult;
58623   NativeImageSourcePtrHandle* handle = (NativeImageSourcePtrHandle*)jarg1;
58624   jresult = (void*)( handle->Ptr.Get() );
58625   return jresult;
58626 }
58627
58628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageSource_Delete(void* jarg1) {
58629   NativeImageSourcePtrHandle* arg1 = (NativeImageSourcePtrHandle*)jarg1;
58630   {
58631     try {
58632       delete arg1;
58633     }
58634     catch (std::out_of_range & e) {
58635       {
58636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
58637       };
58638     }
58639     catch (std::exception & e) {
58640       {
58641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
58642       };
58643     }
58644     catch (Dali::DaliException e) {
58645       {
58646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return;
58647       };
58648     }
58649     catch (...) {
58650       {
58651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return;
58652       };
58653     }
58654   }
58655 }
58656
58657 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_AcquireBuffer(void* jarg1, int* jarg2, int* jarg3, int* jarg4)
58658 {
58659   void* jresult;
58660   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
58661   uint16_t* arg2 = (uint16_t*)(jarg2);
58662   uint16_t* arg3 = (uint16_t*)(jarg3);
58663   uint16_t* arg4 = (uint16_t*)(jarg4);
58664   {
58665     try {
58666       jresult = (void *)Dali::DevelNativeImageSource::AcquireBuffer( *arg1, *arg2, *arg3, *arg4 );
58667     }
58668     catch (std::out_of_range & e) {
58669       {
58670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58671       };
58672     }
58673     catch (std::exception & e) {
58674       {
58675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58676       };
58677     }
58678     catch (Dali::DaliException e) {
58679       {
58680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58681       };
58682     }
58683     catch (...) {
58684       {
58685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58686       };
58687     }
58688   }
58689   return jresult;
58690 }
58691
58692 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NativeImageSource_ReleaseBuffer(void* jarg1)
58693 {
58694   bool jresult;
58695   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
58696
58697   {
58698     try {
58699       jresult = Dali::DevelNativeImageSource::ReleaseBuffer( *arg1 );
58700     }
58701     catch (std::out_of_range & e) {
58702       {
58703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58704       };
58705     }
58706     catch (std::exception & e) {
58707       {
58708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58709       };
58710     }
58711     catch (Dali::DaliException e) {
58712       {
58713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58714       };
58715     }
58716     catch (...) {
58717       {
58718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58719       };
58720     }
58721   }
58722   return jresult;
58723 }
58724
58725
58726 #ifdef __cplusplus
58727 }
58728 #endif