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/hover-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 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_type_get(void * jarg1) {
19052   int jresult ;
19053   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
19054   Dali::Gesture::Type result;
19055
19056   arg1 = (Dali::Gesture *)jarg1;
19057   result = (Dali::Gesture::Type) ((arg1)->GetType());
19058   jresult = (int)result;
19059   return jresult;
19060 }
19061
19062 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_state_get(void * jarg1) {
19063   int jresult ;
19064   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
19065   Dali::Gesture::State result;
19066
19067   arg1 = (Dali::Gesture *)jarg1;
19068   result = (Dali::Gesture::State) ((arg1)->GetState());
19069   jresult = (int)result;
19070   return jresult;
19071 }
19072
19073 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Gesture_time_get(void * jarg1) {
19074   unsigned int jresult ;
19075   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
19076   unsigned int result;
19077
19078   arg1 = (Dali::Gesture *)jarg1;
19079   result = (unsigned int) ((arg1)->GetTime());
19080   jresult = result;
19081   return jresult;
19082 }
19083
19084
19085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_0() {
19086   void * jresult ;
19087   Dali::HoverEvent *result = 0 ;
19088
19089   {
19090     try {
19091       result = (Dali::HoverEvent *)new Dali::HoverEvent();
19092     } CALL_CATCH_EXCEPTION(0);
19093   }
19094
19095   jresult = (void *)result;
19096   return jresult;
19097 }
19098
19099
19100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_1(void * jarg1) {
19101   void * jresult ;
19102   Dali::HoverEvent *arg1 = 0 ;
19103   Dali::HoverEvent *result = 0 ;
19104
19105   arg1 = (Dali::HoverEvent *)jarg1;
19106   if (!arg1) {
19107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
19108     return 0;
19109   }
19110   {
19111     try {
19112       result = (Dali::HoverEvent *)new Dali::HoverEvent((Dali::HoverEvent const &)*arg1);
19113     } CALL_CATCH_EXCEPTION(0);
19114   }
19115
19116   jresult = (void *)result;
19117   return jresult;
19118 }
19119
19120
19121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Hover(void * jarg1) {
19122   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
19123
19124   arg1 = (Dali::HoverEvent *)jarg1;
19125   {
19126     try {
19127       delete arg1;
19128     } CALL_CATCH_EXCEPTION();
19129   }
19130
19131 }
19132
19133
19134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_Assign(void * jarg1, void * jarg2) {
19135   void * jresult ;
19136   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
19137   Dali::HoverEvent *arg2 = 0 ;
19138   Dali::HoverEvent *result = 0 ;
19139
19140   arg1 = (Dali::HoverEvent *)jarg1;
19141   arg2 = (Dali::HoverEvent *)jarg2;
19142   if (!arg2) {
19143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
19144     return 0;
19145   }
19146   {
19147     try {
19148       result = (Dali::HoverEvent *) &(arg1)->operator =((Dali::HoverEvent const &)*arg2);
19149     } catch (std::out_of_range& e) {
19150       {
19151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19152       };
19153     } catch (std::exception& e) {
19154       {
19155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19156       };
19157     } catch (Dali::DaliException e) {
19158       {
19159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19160       };
19161     } catch (...) {
19162       {
19163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19164       };
19165     }
19166   }
19167
19168   jresult = (void *)result;
19169   return jresult;
19170 }
19171
19172
19173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_New(unsigned int jarg1) {
19174   void * jresult ;
19175   unsigned int arg1 ;
19176   Dali::HoverEvent result;
19177
19178   arg1 = (unsigned int)jarg1;
19179   {
19180     try {
19181       result = DevelHoverEvent::New(arg1);
19182     } CALL_CATCH_EXCEPTION(0);
19183   }
19184
19185   jresult = new Dali::HoverEvent((const Dali::HoverEvent &)result);
19186   return jresult;
19187 }
19188
19189
19190 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_GetTime(void * jarg1) {
19191   unsigned long jresult ;
19192   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
19193   unsigned long result;
19194
19195   arg1 = (Dali::HoverEvent *)jarg1;
19196   {
19197     try {
19198       result = (unsigned long)((Dali::HoverEvent const *)arg1)->GetTime();
19199     } catch (std::out_of_range& e) {
19200       {
19201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19202       };
19203     } catch (std::exception& e) {
19204       {
19205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19206       };
19207     } catch (Dali::DaliException e) {
19208       {
19209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19210       };
19211     } catch (...) {
19212       {
19213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19214       };
19215     }
19216   }
19217
19218   jresult = (unsigned long)result;
19219   return jresult;
19220 }
19221
19222
19223 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_GetPointCount(void * jarg1) {
19224   unsigned long jresult ;
19225   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
19226   std::size_t result;
19227
19228   arg1 = (Dali::HoverEvent *)jarg1;
19229   {
19230     try {
19231       result = ((Dali::HoverEvent const *)arg1)->GetPointCount();
19232     } catch (std::out_of_range& e) {
19233       {
19234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19235       };
19236     } catch (std::exception& e) {
19237       {
19238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19239       };
19240     } catch (Dali::DaliException e) {
19241       {
19242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19243       };
19244     } catch (...) {
19245       {
19246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19247       };
19248     }
19249   }
19250
19251   jresult = (unsigned long)result;
19252   return jresult;
19253 }
19254
19255
19256 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Hover_GetDeviceId(void * jarg1, unsigned long jarg2) {
19257   int jresult ;
19258   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
19259   std::size_t arg2 ;
19260   int32_t result;
19261
19262   arg1 = (Dali::HoverEvent *)jarg1;
19263   arg2 = (std::size_t)jarg2;
19264   {
19265     try {
19266       result = ((Dali::HoverEvent const *)arg1)->GetDeviceId(arg2);
19267     } catch (std::out_of_range& e) {
19268       {
19269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19270       };
19271     } catch (std::exception& e) {
19272       {
19273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19274       };
19275     } catch (Dali::DaliException e) {
19276       {
19277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19278       };
19279     } catch (...) {
19280       {
19281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19282       };
19283     }
19284   }
19285
19286   jresult = result;
19287   return jresult;
19288 }
19289
19290
19291 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Hover_GetState(void * jarg1, unsigned long jarg2) {
19292   int jresult ;
19293   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
19294   std::size_t arg2 ;
19295   Dali::PointState::Type result;
19296
19297   arg1 = (Dali::HoverEvent *)jarg1;
19298   arg2 = (std::size_t)jarg2;
19299   {
19300     try {
19301       result = (Dali::PointState::Type)((Dali::HoverEvent const *)arg1)->GetState(arg2);
19302     } CALL_CATCH_EXCEPTION(0);
19303   }
19304
19305   jresult = (int)result;
19306   return jresult;
19307 }
19308
19309
19310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetHitActor(void * jarg1, unsigned long jarg2) {
19311   void * jresult ;
19312   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
19313   std::size_t arg2 ;
19314   Dali::Actor result;
19315
19316   arg1 = (Dali::HoverEvent *)jarg1;
19317   arg2 = (std::size_t)jarg2;
19318   {
19319     try {
19320       result = ((Dali::HoverEvent const *)arg1)->GetHitActor(arg2);
19321     } catch (std::out_of_range& e) {
19322       {
19323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19324       };
19325     } catch (std::exception& e) {
19326       {
19327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19328       };
19329     } catch (Dali::DaliException e) {
19330       {
19331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19332       };
19333     } catch (...) {
19334       {
19335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19336       };
19337     }
19338   }
19339
19340   jresult = new Dali::Actor((const Dali::Actor &)result);
19341   return jresult;
19342 }
19343
19344
19345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetLocalPosition(void * jarg1, unsigned long jarg2) {
19346   void * jresult ;
19347   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
19348   std::size_t arg2 ;
19349   Dali::Vector2 *result = 0 ;
19350
19351   arg1 = (Dali::HoverEvent *)jarg1;
19352   arg2 = (std::size_t)jarg2;
19353   {
19354     try {
19355       result = (Dali::Vector2 *) &((Dali::HoverEvent const *)arg1)->GetLocalPosition(arg2);
19356     } catch (std::out_of_range& e) {
19357       {
19358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19359       };
19360     } catch (std::exception& e) {
19361       {
19362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19363       };
19364     } catch (Dali::DaliException e) {
19365       {
19366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19367       };
19368     } catch (...) {
19369       {
19370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19371       };
19372     }
19373   }
19374
19375   jresult = (void *)result;
19376   return jresult;
19377 }
19378
19379
19380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetScreenPosition(void * jarg1, unsigned long jarg2) {
19381   void * jresult ;
19382   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
19383   std::size_t arg2 ;
19384   Dali::Vector2 *result = 0 ;
19385
19386   arg1 = (Dali::HoverEvent *)jarg1;
19387   arg2 = (std::size_t)jarg2;
19388   {
19389     try {
19390       result = (Dali::Vector2 *) &((Dali::HoverEvent const *)arg1)->GetScreenPosition(arg2);
19391     } CALL_CATCH_EXCEPTION(0);
19392   }
19393
19394   jresult = (void *)result;
19395   return jresult;
19396 }
19397
19398
19399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_0() {
19400   void * jresult ;
19401   Dali::KeyEvent *result = 0 ;
19402
19403   {
19404     try {
19405       result = (Dali::KeyEvent *)new Dali::KeyEvent();
19406     } CALL_CATCH_EXCEPTION(0);
19407   }
19408
19409   jresult = (void *)result;
19410   return jresult;
19411 }
19412
19413
19414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_1(void * jarg1) {
19415   void * jresult ;
19416   Dali::KeyEvent *arg1 = 0 ;
19417   Dali::KeyEvent *result = 0 ;
19418
19419   arg1 = (Dali::KeyEvent *)jarg1;
19420   if (!arg1) {
19421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
19422     return 0;
19423   }
19424   {
19425     try {
19426       result = (Dali::KeyEvent *)new Dali::KeyEvent((Dali::KeyEvent const &)*arg1);
19427     } CALL_CATCH_EXCEPTION(0);
19428   }
19429
19430   jresult = (void *)result;
19431   return jresult;
19432 }
19433
19434
19435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_Assign(void * jarg1, void * jarg2) {
19436   void * jresult ;
19437   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
19438   Dali::KeyEvent *arg2 = 0 ;
19439   Dali::KeyEvent *result = 0 ;
19440
19441   arg1 = (Dali::KeyEvent *)jarg1;
19442   arg2 = (Dali::KeyEvent *)jarg2;
19443   if (!arg2) {
19444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
19445     return 0;
19446   }
19447   {
19448     try {
19449       result = (Dali::KeyEvent *) &(arg1)->operator =((Dali::KeyEvent const &)*arg2);
19450     } CALL_CATCH_EXCEPTION(0);
19451   }
19452
19453   jresult = (void *)result;
19454   return jresult;
19455 }
19456
19457
19458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_New(char * jarg1, char * jarg2, int jarg3, int jarg4, unsigned long jarg5, int jarg6) {
19459   void * jresult ;
19460   std::string *arg1 = 0 ;
19461   std::string *arg2 = 0 ;
19462   int arg3 ;
19463   int arg4 ;
19464   unsigned long arg5 ;
19465   Dali::KeyEvent::State *arg6 = 0 ;
19466   Dali::KeyEvent::State temp6 ;
19467   Dali::KeyEvent result;
19468
19469   if (!jarg1) {
19470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19471     return 0;
19472   }
19473   std::string arg1_str(jarg1);
19474   arg1 = &arg1_str;
19475   if (!jarg2) {
19476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19477     return 0;
19478   }
19479   std::string arg2_str(jarg2);
19480   arg2 = &arg2_str;
19481   arg3 = (int)jarg3;
19482   arg4 = (int)jarg4;
19483   arg5 = (unsigned long)jarg5;
19484   temp6 = (Dali::KeyEvent::State)jarg6;
19485   arg6 = &temp6;
19486   {
19487     try {
19488       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);
19489     } CALL_CATCH_EXCEPTION(0);
19490   }
19491
19492   jresult = new Dali::KeyEvent((const Dali::KeyEvent &)result);
19493
19494   //argout typemap for const std::string&
19495
19496
19497   //argout typemap for const std::string&
19498
19499   return jresult;
19500 }
19501
19502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Key(void * jarg1) {
19503   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
19504
19505   arg1 = (Dali::KeyEvent *)jarg1;
19506   {
19507     try {
19508       delete arg1;
19509     } CALL_CATCH_EXCEPTION();
19510   }
19511
19512 }
19513
19514
19515 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsShiftModifier(void * jarg1) {
19516   unsigned int jresult ;
19517   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
19518   bool result;
19519
19520   arg1 = (Dali::KeyEvent *)jarg1;
19521   {
19522     try {
19523       result = (bool)((Dali::KeyEvent const *)arg1)->IsShiftModifier();
19524     } CALL_CATCH_EXCEPTION(0);
19525   }
19526
19527   jresult = result;
19528   return jresult;
19529 }
19530
19531
19532 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsCtrlModifier(void * jarg1) {
19533   unsigned int jresult ;
19534   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
19535   bool result;
19536
19537   arg1 = (Dali::KeyEvent *)jarg1;
19538   {
19539     try {
19540       result = (bool)((Dali::KeyEvent const *)arg1)->IsCtrlModifier();
19541     } CALL_CATCH_EXCEPTION(0);
19542   }
19543
19544   jresult = result;
19545   return jresult;
19546 }
19547
19548
19549 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsAltModifier(void * jarg1) {
19550   unsigned int jresult ;
19551   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
19552   bool result;
19553
19554   arg1 = (Dali::KeyEvent *)jarg1;
19555   {
19556     try {
19557       result = (bool)((Dali::KeyEvent const *)arg1)->IsAltModifier();
19558     } CALL_CATCH_EXCEPTION(0);
19559   }
19560
19561   jresult = result;
19562   return jresult;
19563 }
19564
19565
19566 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressedName_set(void * jarg1, char * jarg2) {
19567   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0 ;
19568   std::string *arg2 = 0 ;
19569
19570   Dali::KeyEvent arg1 = *argp1;
19571   if (!jarg2) {
19572     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19573     return ;
19574   }
19575   std::string arg2_str(jarg2);
19576   arg2 = &arg2_str;
19577
19578   {
19579     try {
19580       Dali::DevelKeyEvent::SetKeyName(arg1, (std::string const &)*arg2);
19581     } catch (std::out_of_range& e) {
19582       {
19583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19584       };
19585     } catch (std::exception& e) {
19586       {
19587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19588       };
19589     } catch (Dali::DaliException e) {
19590       {
19591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19592       };
19593     } catch (...) {
19594       {
19595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19596       };
19597     }
19598   }
19599 }
19600
19601
19602 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressedName_get(void * jarg1) {
19603   char * jresult ;
19604
19605   if( jarg1 == NULL )
19606   {
19607     jresult = SWIG_csharp_string_callback( "" );
19608   }
19609   else
19610   {
19611     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
19612     std::string *result = 0;
19613
19614     arg1 = ( Dali::KeyEvent * )jarg1;
19615     {
19616       try {
19617         std::string str = ((Dali::KeyEvent const *)arg1)->GetKeyName();
19618         result = (std::string *) &str;
19619       } catch (std::out_of_range& e) {
19620         {
19621           SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19622         };
19623       } catch (std::exception& e) {
19624         {
19625           SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19626         };
19627       } catch (Dali::DaliException e) {
19628         {
19629           SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19630         };
19631       } catch (...) {
19632         {
19633           SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19634         };
19635       }
19636     }
19637
19638     jresult = SWIG_csharp_string_callback(result->c_str());
19639   }
19640
19641   return jresult;
19642 }
19643
19644
19645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressed_set(void * jarg1, char * jarg2) {
19646   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0 ;
19647   std::string *arg2 = 0 ;
19648
19649   Dali::KeyEvent arg1 = *argp1;
19650   if (!jarg2) {
19651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19652     return ;
19653   }
19654   std::string arg2_str(jarg2);
19655   arg2 = &arg2_str;
19656
19657   {
19658     try {
19659       Dali::DevelKeyEvent::SetKeyString(arg1, (std::string const &)*arg2);
19660     } catch (std::out_of_range& e) {
19661       {
19662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19663       };
19664     } catch (std::exception& e) {
19665       {
19666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19667       };
19668     } catch (Dali::DaliException e) {
19669       {
19670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19671       };
19672     } catch (...) {
19673       {
19674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19675       };
19676     }
19677   }
19678 }
19679
19680
19681 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressed_get(void * jarg1) {
19682   char * jresult ;
19683
19684   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
19685   std::string *result = 0;
19686
19687   arg1 = ( Dali::KeyEvent * )jarg1;
19688   {
19689     try {
19690       std::string str = ((Dali::KeyEvent const *)arg1)->GetKeyString();
19691       result = (std::string *) &str;
19692     } catch (std::out_of_range& e) {
19693       {
19694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19695       };
19696     } catch (std::exception& e) {
19697       {
19698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19699       };
19700     } catch (Dali::DaliException e) {
19701       {
19702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19703       };
19704     } catch (...) {
19705       {
19706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19707       };
19708     }
19709
19710     jresult = SWIG_csharp_string_callback(result->c_str());
19711   }
19712
19713   return jresult;
19714 }
19715
19716
19717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyCode_set(void * jarg1, int jarg2) {
19718   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0 ;
19719   int arg2 ;
19720
19721   Dali::KeyEvent arg1 = *argp1;
19722   arg2 = (int)jarg2;
19723   {
19724     try {
19725       Dali::DevelKeyEvent::SetKeyCode(arg1, arg2);
19726     } catch (std::out_of_range& e) {
19727       {
19728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19729       };
19730     } catch (std::exception& e) {
19731       {
19732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19733       };
19734     } catch (Dali::DaliException e) {
19735       {
19736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19737       };
19738     } catch (...) {
19739       {
19740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19741       };
19742     }
19743   }
19744 }
19745
19746
19747 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyCode_get(void * jarg1) {
19748   int jresult ;
19749   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
19750   int result;
19751
19752   arg1 = (Dali::KeyEvent *)jarg1;
19753   {
19754     try {
19755       result = (int)((Dali::KeyEvent const *)arg1)->GetKeyCode();
19756     } catch (std::out_of_range& e) {
19757       {
19758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19759       };
19760     } catch (std::exception& e) {
19761       {
19762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19763       };
19764     } catch (Dali::DaliException e) {
19765       {
19766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19767       };
19768     } catch (...) {
19769       {
19770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19771       };
19772     }
19773   }
19774
19775   jresult = result;
19776   return jresult;
19777 }
19778
19779
19780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyModifier_set(void * jarg1, int jarg2) {
19781   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0 ;
19782   int arg2 ;
19783
19784   Dali::KeyEvent arg1 = *argp1;
19785   arg2 = (int)jarg2;
19786   {
19787     try {
19788       Dali::DevelKeyEvent::SetKeyModifier(arg1, arg2);
19789     } catch (std::out_of_range& e) {
19790       {
19791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19792       };
19793     } catch (std::exception& e) {
19794       {
19795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19796       };
19797     } catch (Dali::DaliException e) {
19798       {
19799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19800       };
19801     } catch (...) {
19802       {
19803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19804       };
19805     }
19806   }
19807 }
19808
19809
19810 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyModifier_get(void * jarg1) {
19811   int jresult ;
19812   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
19813   int result;
19814
19815   arg1 = (Dali::KeyEvent *)jarg1;
19816   {
19817     try {
19818       result = (int)((Dali::KeyEvent const *)arg1)->GetKeyModifier();
19819     } catch (std::out_of_range& e) {
19820       {
19821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19822       };
19823     } catch (std::exception& e) {
19824       {
19825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19826       };
19827     } catch (Dali::DaliException e) {
19828       {
19829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19830       };
19831     } catch (...) {
19832       {
19833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19834       };
19835     }
19836   }
19837
19838   jresult = result;
19839   return jresult;
19840 }
19841
19842
19843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_time_set(void * jarg1, unsigned long jarg2) {
19844   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0 ;
19845   unsigned long arg2 ;
19846
19847   Dali::KeyEvent arg1 = *argp1;
19848   arg2 = (int)jarg2;
19849   {
19850     try {
19851       Dali::DevelKeyEvent::SetTime(arg1, arg2);
19852     } catch (std::out_of_range& e) {
19853       {
19854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19855       };
19856     } catch (std::exception& e) {
19857       {
19858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19859       };
19860     } catch (Dali::DaliException e) {
19861       {
19862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19863       };
19864     } catch (...) {
19865       {
19866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19867       };
19868     }
19869   }
19870 }
19871
19872
19873 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Key_time_get(void * jarg1) {
19874   unsigned long jresult ;
19875   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
19876   unsigned long result;
19877
19878   arg1 = (Dali::KeyEvent *)jarg1;
19879   {
19880     try {
19881       result = (int)((Dali::KeyEvent const *)arg1)->GetTime();
19882     } catch (std::out_of_range& e) {
19883       {
19884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19885       };
19886     } catch (std::exception& e) {
19887       {
19888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19889       };
19890     } catch (Dali::DaliException e) {
19891       {
19892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19893       };
19894     } catch (...) {
19895       {
19896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19897       };
19898     }
19899   }
19900
19901   jresult = result;
19902   return jresult;
19903 }
19904
19905
19906 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_state_set(void * jarg1, int jarg2) {
19907   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0;
19908   Dali::KeyEvent::State arg2;
19909
19910   Dali::KeyEvent arg1 = *argp1;
19911   arg2 = (Dali::KeyEvent::State)jarg2;
19912   {
19913     try {
19914       Dali::DevelKeyEvent::SetState(arg1, arg2);
19915     } catch (std::out_of_range& e) {
19916       {
19917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19918       };
19919     } catch (std::exception& e) {
19920       {
19921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19922       };
19923     } catch (Dali::DaliException e) {
19924       {
19925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19926       };
19927     } catch (...) {
19928       {
19929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19930       };
19931     }
19932   }
19933 }
19934
19935
19936 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_state_get(void * jarg1) {
19937   int jresult ;
19938   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
19939   Dali::KeyEvent::State result;
19940
19941   arg1 = (Dali::KeyEvent *)jarg1;
19942   {
19943     try {
19944       result = (Dali::KeyEvent::State)((Dali::KeyEvent const *)arg1)->GetState();
19945     } catch (std::out_of_range& e) {
19946       {
19947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19948       };
19949     } catch (std::exception& e) {
19950       {
19951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19952       };
19953     } catch (Dali::DaliException e) {
19954       {
19955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19956       };
19957     } catch (...) {
19958       {
19959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19960       };
19961     }
19962   }
19963
19964   jresult = (int)result;
19965   return jresult;
19966
19967 }
19968
19969 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_logicalKey_get(void * jarg1) {
19970   char * jresult ;
19971
19972   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
19973   std::string *result = 0;
19974
19975   arg1 = ( Dali::KeyEvent * )jarg1;
19976   {
19977     try {
19978       std::string str = ((Dali::KeyEvent const *)arg1)->GetLogicalKey();
19979       result = (std::string *) &str;
19980     } CALL_CATCH_EXCEPTION(0);
19981
19982   }
19983
19984   jresult = SWIG_csharp_string_callback(result->c_str());
19985   return jresult;
19986 }
19987
19988
19989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_0() {
19990   void * jresult ;
19991   Dali::LongPressGestureDetector *result = 0 ;
19992
19993   {
19994     try {
19995       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector();
19996     } CALL_CATCH_EXCEPTION(0);
19997   }
19998
19999   jresult = (void *)result;
20000   return jresult;
20001 }
20002
20003
20004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_0() {
20005   void * jresult ;
20006   Dali::LongPressGestureDetector result;
20007
20008   {
20009     try {
20010       result = Dali::LongPressGestureDetector::New();
20011     } CALL_CATCH_EXCEPTION(0);
20012   }
20013
20014   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
20015   return jresult;
20016 }
20017
20018
20019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_1(unsigned int jarg1) {
20020   void * jresult ;
20021   unsigned int arg1 ;
20022   Dali::LongPressGestureDetector result;
20023
20024   arg1 = (unsigned int)jarg1;
20025   {
20026     try {
20027       result = Dali::LongPressGestureDetector::New(arg1);
20028     } CALL_CATCH_EXCEPTION(0);
20029   }
20030
20031   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
20032   return jresult;
20033 }
20034
20035
20036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
20037   void * jresult ;
20038   unsigned int arg1 ;
20039   unsigned int arg2 ;
20040   Dali::LongPressGestureDetector result;
20041
20042   arg1 = (unsigned int)jarg1;
20043   arg2 = (unsigned int)jarg2;
20044   {
20045     try {
20046       result = Dali::LongPressGestureDetector::New(arg1,arg2);
20047     } CALL_CATCH_EXCEPTION(0);
20048   }
20049
20050   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
20051   return jresult;
20052 }
20053
20054
20055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DownCast(void * jarg1) {
20056   void * jresult ;
20057   Dali::BaseHandle arg1 ;
20058   Dali::BaseHandle *argp1 ;
20059   Dali::LongPressGestureDetector result;
20060
20061   argp1 = (Dali::BaseHandle *)jarg1;
20062   if (!argp1) {
20063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
20064     return 0;
20065   }
20066   arg1 = *argp1;
20067   {
20068     try {
20069       result = Dali::LongPressGestureDetector::DownCast(arg1);
20070     } CALL_CATCH_EXCEPTION(0);
20071   }
20072
20073   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
20074   return jresult;
20075 }
20076
20077
20078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetector(void * jarg1) {
20079   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
20080
20081   arg1 = (Dali::LongPressGestureDetector *)jarg1;
20082   {
20083     try {
20084       delete arg1;
20085     } CALL_CATCH_EXCEPTION();
20086   }
20087
20088 }
20089
20090
20091 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_1(void * jarg1) {
20092   void * jresult ;
20093   Dali::LongPressGestureDetector *arg1 = 0 ;
20094   Dali::LongPressGestureDetector *result = 0 ;
20095
20096   arg1 = (Dali::LongPressGestureDetector *)jarg1;
20097   if (!arg1) {
20098     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
20099     return 0;
20100   }
20101   {
20102     try {
20103       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector((Dali::LongPressGestureDetector const &)*arg1);
20104     } CALL_CATCH_EXCEPTION(0);
20105   }
20106
20107   jresult = (void *)result;
20108   return jresult;
20109 }
20110
20111
20112 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_Assign(void * jarg1, void * jarg2) {
20113   void * jresult ;
20114   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
20115   Dali::LongPressGestureDetector *arg2 = 0 ;
20116   Dali::LongPressGestureDetector *result = 0 ;
20117
20118   arg1 = (Dali::LongPressGestureDetector *)jarg1;
20119   arg2 = (Dali::LongPressGestureDetector *)jarg2;
20120   if (!arg2) {
20121     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
20122     return 0;
20123   }
20124   {
20125     try {
20126       result = (Dali::LongPressGestureDetector *) &(arg1)->operator =((Dali::LongPressGestureDetector const &)*arg2);
20127     } CALL_CATCH_EXCEPTION(0);
20128   }
20129
20130   jresult = (void *)result;
20131   return jresult;
20132 }
20133
20134
20135 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_0(void * jarg1, unsigned int jarg2) {
20136   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
20137   unsigned int arg2 ;
20138
20139   arg1 = (Dali::LongPressGestureDetector *)jarg1;
20140   arg2 = (unsigned int)jarg2;
20141   {
20142     try {
20143       (arg1)->SetTouchesRequired(arg2);
20144     } CALL_CATCH_EXCEPTION();
20145   }
20146
20147 }
20148
20149
20150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
20151   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
20152   unsigned int arg2 ;
20153   unsigned int arg3 ;
20154
20155   arg1 = (Dali::LongPressGestureDetector *)jarg1;
20156   arg2 = (unsigned int)jarg2;
20157   arg3 = (unsigned int)jarg3;
20158   {
20159     try {
20160       (arg1)->SetTouchesRequired(arg2,arg3);
20161     } CALL_CATCH_EXCEPTION();
20162   }
20163
20164 }
20165
20166
20167 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
20168   unsigned int jresult ;
20169   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
20170   unsigned int result;
20171
20172   arg1 = (Dali::LongPressGestureDetector *)jarg1;
20173   {
20174     try {
20175       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMinimumTouchesRequired();
20176     } CALL_CATCH_EXCEPTION(0);
20177   }
20178
20179   jresult = result;
20180   return jresult;
20181 }
20182
20183
20184 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
20185   unsigned int jresult ;
20186   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
20187   unsigned int result;
20188
20189   arg1 = (Dali::LongPressGestureDetector *)jarg1;
20190   {
20191     try {
20192       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMaximumTouchesRequired();
20193     } CALL_CATCH_EXCEPTION(0);
20194   }
20195
20196   jresult = result;
20197   return jresult;
20198 }
20199
20200
20201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DetectedSignal(void * jarg1) {
20202   void * jresult ;
20203   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
20204   Dali::LongPressGestureDetector::DetectedSignalType *result = 0 ;
20205
20206   arg1 = (Dali::LongPressGestureDetector *)jarg1;
20207   {
20208     try {
20209       result = (Dali::LongPressGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
20210     } CALL_CATCH_EXCEPTION(0);
20211   }
20212
20213   jresult = (void *)result;
20214   return jresult;
20215 }
20216
20217
20218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_0() {
20219   void * jresult ;
20220   Dali::LongPressGesture *result = 0 ;
20221
20222   {
20223     try {
20224       result = (Dali::LongPressGesture *)new Dali::LongPressGesture();
20225     } CALL_CATCH_EXCEPTION(0);
20226   }
20227
20228   jresult = (void *)result;
20229   return jresult;
20230 }
20231
20232
20233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_1(void * jarg1) {
20234   void * jresult ;
20235   Dali::LongPressGesture *arg1 = 0 ;
20236   Dali::LongPressGesture *result = 0 ;
20237
20238   arg1 = (Dali::LongPressGesture *)jarg1;
20239   if (!arg1) {
20240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
20241     return 0;
20242   }
20243   {
20244     try {
20245       result = (Dali::LongPressGesture *)new Dali::LongPressGesture((Dali::LongPressGesture const &)*arg1);
20246     } CALL_CATCH_EXCEPTION(0);
20247   }
20248
20249   jresult = (void *)result;
20250   return jresult;
20251 }
20252
20253
20254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_Assign(void * jarg1, void * jarg2) {
20255   void * jresult ;
20256   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
20257   Dali::LongPressGesture *arg2 = 0 ;
20258   Dali::LongPressGesture *result = 0 ;
20259
20260   arg1 = (Dali::LongPressGesture *)jarg1;
20261   arg2 = (Dali::LongPressGesture *)jarg2;
20262   if (!arg2) {
20263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
20264     return 0;
20265   }
20266   {
20267     try {
20268       result = (Dali::LongPressGesture *) &(arg1)->operator =((Dali::LongPressGesture const &)*arg2);
20269     } CALL_CATCH_EXCEPTION(0);
20270   }
20271
20272   jresult = (void *)result;
20273   return jresult;
20274 }
20275
20276
20277 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGesture(void * jarg1) {
20278   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
20279
20280   arg1 = (Dali::LongPressGesture *)jarg1;
20281   {
20282     try {
20283       delete arg1;
20284     } CALL_CATCH_EXCEPTION();
20285   }
20286
20287 }
20288
20289
20290 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_get(void * jarg1) {
20291   unsigned int jresult ;
20292   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
20293   unsigned int result;
20294
20295   arg1 = (Dali::LongPressGesture *)jarg1;
20296   result = (unsigned int) ((arg1)->GetNumberOfTouches());
20297   jresult = result;
20298   return jresult;
20299 }
20300
20301
20302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_get(void * jarg1) {
20303   void * jresult ;
20304   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
20305   Dali::Vector2 result;
20306
20307   arg1 = (Dali::LongPressGesture *)jarg1;
20308   {
20309     try {
20310       result = ((Dali::LongPressGesture const *)arg1)->GetScreenPoint();
20311     } catch (std::out_of_range& e) {
20312       {
20313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20314       };
20315     } catch (std::exception& e) {
20316       {
20317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20318       };
20319     } catch (Dali::DaliException e) {
20320       {
20321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20322       };
20323     } catch (...) {
20324       {
20325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20326       };
20327     }
20328   }
20329   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
20330   return jresult;
20331 }
20332
20333
20334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_get(void * jarg1) {
20335   void * jresult ;
20336   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
20337   Dali::Vector2 result;
20338
20339   arg1 = (Dali::LongPressGesture *)jarg1;
20340   {
20341     try {
20342       result = ((Dali::LongPressGesture const *)arg1)->GetLocalPoint();
20343     } catch (std::out_of_range& e) {
20344       {
20345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20346       };
20347     } catch (std::exception& e) {
20348       {
20349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20350       };
20351     } catch (Dali::DaliException e) {
20352       {
20353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20354       };
20355     } catch (...) {
20356       {
20357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20358       };
20359     }
20360   }
20361   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
20362   return jresult;
20363 }
20364
20365
20366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_0() {
20367   void * jresult ;
20368   Dali::WheelEvent *result = 0 ;
20369
20370   {
20371     try {
20372       result = (Dali::WheelEvent *)new Dali::WheelEvent();
20373     } CALL_CATCH_EXCEPTION(0);
20374   }
20375
20376   jresult = (void *)result;
20377   return jresult;
20378 }
20379
20380
20381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_1(void * jarg1) {
20382   void * jresult ;
20383   Dali::WheelEvent *arg1 = 0 ;
20384   Dali::WheelEvent *result = 0 ;
20385
20386   arg1 = (Dali::WheelEvent *)jarg1;
20387   if (!arg1) {
20388     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
20389     return 0;
20390   }
20391   {
20392     try {
20393       result = (Dali::WheelEvent *)new Dali::WheelEvent((Dali::WheelEvent const &)*arg1);
20394     } catch (std::out_of_range& e) {
20395       {
20396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20397       };
20398     } catch (std::exception& e) {
20399       {
20400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20401       };
20402     } catch (Dali::DaliException e) {
20403       {
20404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20405       };
20406     } catch (...) {
20407       {
20408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20409       };
20410     }
20411   }
20412
20413   jresult = (void *)result;
20414   return jresult;
20415 }
20416
20417
20418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_Assign(void * jarg1, void * jarg2) {
20419   void * jresult ;
20420   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
20421   Dali::WheelEvent *arg2 = 0 ;
20422   Dali::WheelEvent *result = 0 ;
20423
20424   arg1 = (Dali::WheelEvent *)jarg1;
20425   arg2 = (Dali::WheelEvent *)jarg2;
20426   if (!arg2) {
20427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
20428     return 0;
20429   }
20430   {
20431     try {
20432       result = (Dali::WheelEvent *) &(arg1)->operator =((Dali::WheelEvent const &)*arg2);
20433     } catch (std::out_of_range& e) {
20434       {
20435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20436       };
20437     } catch (std::exception& e) {
20438       {
20439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20440       };
20441     } catch (Dali::DaliException e) {
20442       {
20443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20444       };
20445     } catch (...) {
20446       {
20447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20448       };
20449     }
20450   }
20451
20452   jresult = (void *)result;
20453   return jresult;
20454 }
20455
20456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_New(int jarg1, int jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6) {
20457   void * jresult ;
20458   Dali::WheelEvent::Type arg1 ;
20459   int arg2 ;
20460   unsigned int arg3 ;
20461   Dali::Vector2 arg4 ;
20462   int arg5 ;
20463   unsigned int arg6 ;
20464   Dali::Vector2 *argp4 ;
20465   Dali::WheelEvent result;
20466
20467   arg1 = (Dali::WheelEvent::Type)jarg1;
20468   arg2 = (int)jarg2;
20469   arg3 = (unsigned int)jarg3;
20470   argp4 = (Dali::Vector2 *)jarg4;
20471   if (!argp4) {
20472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
20473     return 0;
20474   }
20475   arg4 = *argp4;
20476   arg5 = (int)jarg5;
20477   arg6 = (unsigned int)jarg6;
20478   {
20479     try {
20480       result = DevelWheelEvent::New(arg1,arg2,arg3,arg4,arg5,arg6);
20481     } CALL_CATCH_EXCEPTION(0);
20482   }
20483
20484   jresult = new Dali::WheelEvent((const Dali::WheelEvent &)result);
20485   return jresult;
20486 }
20487
20488
20489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Wheel(void * jarg1) {
20490   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
20491
20492   arg1 = (Dali::WheelEvent *)jarg1;
20493   {
20494     try {
20495       delete arg1;
20496     } CALL_CATCH_EXCEPTION();
20497   }
20498
20499 }
20500
20501
20502 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsShiftModifier(void * jarg1) {
20503   unsigned int jresult ;
20504   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
20505   bool result;
20506
20507   arg1 = (Dali::WheelEvent *)jarg1;
20508   {
20509     try {
20510       result = (bool)((Dali::WheelEvent const *)arg1)->IsShiftModifier();
20511     } CALL_CATCH_EXCEPTION(0);
20512   }
20513
20514   jresult = result;
20515   return jresult;
20516 }
20517
20518
20519 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsCtrlModifier(void * jarg1) {
20520   unsigned int jresult ;
20521   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
20522   bool result;
20523
20524   arg1 = (Dali::WheelEvent *)jarg1;
20525   {
20526     try {
20527       result = (bool)((Dali::WheelEvent const *)arg1)->IsCtrlModifier();
20528     } catch (std::out_of_range& e) {
20529       {
20530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20531       };
20532     } catch (std::exception& e) {
20533       {
20534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20535       };
20536     } catch (Dali::DaliException e) {
20537       {
20538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20539       };
20540     } catch (...) {
20541       {
20542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20543       };
20544     }
20545   }
20546
20547   jresult = result;
20548   return jresult;
20549 }
20550
20551
20552 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsAltModifier(void * jarg1) {
20553   unsigned int jresult ;
20554   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
20555   bool result;
20556
20557   arg1 = (Dali::WheelEvent *)jarg1;
20558   {
20559     try {
20560       result = (bool)((Dali::WheelEvent const *)arg1)->IsAltModifier();
20561     } catch (std::out_of_range& e) {
20562       {
20563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20564       };
20565     } catch (std::exception& e) {
20566       {
20567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20568       };
20569     } catch (Dali::DaliException e) {
20570       {
20571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20572       };
20573     } catch (...) {
20574       {
20575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20576       };
20577     }
20578   }
20579
20580   jresult = result;
20581   return jresult;
20582 }
20583
20584
20585 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_type_get(void * jarg1) {
20586   int jresult ;
20587   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
20588   Dali::WheelEvent::Type result;
20589
20590   arg1 = (Dali::WheelEvent *)jarg1;
20591   {
20592     try {
20593       result = ((Dali::WheelEvent const *)arg1)->GetType();
20594     } catch (std::out_of_range& e) {
20595       {
20596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20597       };
20598     } catch (std::exception& e) {
20599       {
20600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20601       };
20602     } catch (Dali::DaliException e) {
20603       {
20604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20605       };
20606     } catch (...) {
20607       {
20608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20609       };
20610     }
20611   }
20612
20613   jresult = (int)result;
20614   return jresult;
20615 }
20616
20617
20618 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_direction_get(void * jarg1) {
20619   int jresult ;
20620   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
20621   int result;
20622
20623   arg1 = (Dali::WheelEvent *)jarg1;
20624   {
20625     try {
20626       result = ((Dali::WheelEvent const *)arg1)->GetDirection();
20627     } catch (std::out_of_range& e) {
20628       {
20629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20630       };
20631     } catch (std::exception& e) {
20632       {
20633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20634       };
20635     } catch (Dali::DaliException e) {
20636       {
20637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20638       };
20639     } catch (...) {
20640       {
20641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20642       };
20643     }
20644   }
20645
20646   jresult = result;
20647   return jresult;
20648 }
20649
20650
20651 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_modifiers_get(void * jarg1) {
20652   unsigned int jresult ;
20653   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
20654   unsigned int result;
20655
20656   arg1 = (Dali::WheelEvent *)jarg1;
20657   {
20658     try {
20659       result = ((Dali::WheelEvent const *)arg1)->GetModifiers();
20660     } CALL_CATCH_EXCEPTION(0);
20661   }
20662
20663   jresult = result;
20664   return jresult;
20665 }
20666
20667
20668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_point_get(void * jarg1) {
20669   void * jresult ;
20670   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
20671   Dali::Vector2 *result = 0 ;
20672
20673   arg1 = (Dali::WheelEvent *)jarg1;
20674   {
20675     try {
20676       result = (Dali::Vector2 *) &((Dali::WheelEvent const *)arg1)->GetPoint();
20677     } CALL_CATCH_EXCEPTION(0);
20678   }
20679
20680   jresult = (void *)result;
20681   return jresult;
20682 }
20683
20684
20685 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_delta_get(void * jarg1) {
20686   int jresult ;
20687   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
20688   int result;
20689
20690   arg1 = (Dali::WheelEvent *)jarg1;
20691   {
20692     try {
20693       result = ((Dali::WheelEvent const *)arg1)->GetDelta();
20694     } catch (std::out_of_range& e) {
20695       {
20696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20697       };
20698     } catch (std::exception& e) {
20699       {
20700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20701       };
20702     } catch (Dali::DaliException e) {
20703       {
20704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20705       };
20706     } catch (...) {
20707       {
20708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20709       };
20710     }
20711   }
20712
20713   jresult = result;
20714   return jresult;
20715 }
20716
20717
20718 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_get(void * jarg1) {
20719   unsigned int jresult ;
20720   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
20721   unsigned int result;
20722
20723   arg1 = (Dali::WheelEvent *)jarg1;
20724   {
20725     try {
20726       result = ((Dali::WheelEvent const *)arg1)->GetTime();
20727     } catch (std::out_of_range& e) {
20728       {
20729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20730       };
20731     } catch (std::exception& e) {
20732       {
20733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20734       };
20735     } catch (Dali::DaliException e) {
20736       {
20737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20738       };
20739     } catch (...) {
20740       {
20741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20742       };
20743     }
20744   }
20745
20746   jresult = result;
20747   return jresult;
20748 }
20749
20750 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetDeviceName(void * jarg1) {
20751   char * jresult ;
20752   Dali::KeyEvent *arg1 = 0 ;
20753   std::string result;
20754
20755   arg1 = (Dali::KeyEvent *)jarg1;
20756   if (!arg1) {
20757     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
20758     return 0;
20759   }
20760   {
20761     try {
20762       result = arg1->GetDeviceName();
20763     } CALL_CATCH_EXCEPTION(0);
20764   }
20765
20766   jresult = SWIG_csharp_string_callback((&result)->c_str());
20767   return jresult;
20768 }
20769
20770 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceClass(void * jarg1) {
20771   int jresult ;
20772   Dali::KeyEvent *arg1 = 0 ;
20773   Dali::Device::Class::Type result;
20774
20775   arg1 = (Dali::KeyEvent *)jarg1;
20776   if (!arg1) {
20777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
20778     return 0;
20779   }
20780   {
20781     try {
20782       result = (Dali::Device::Class::Type)arg1->GetDeviceClass();
20783     } CALL_CATCH_EXCEPTION(0);
20784   }
20785
20786   jresult = (int)result;
20787   return jresult;
20788 }
20789
20790 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceSubClass(void * jarg1) {
20791   int jresult ;
20792   Dali::KeyEvent *arg1 = 0 ;
20793   Dali::Device::Subclass::Type result;
20794
20795   arg1 = (Dali::KeyEvent *)jarg1;
20796   if (!arg1) {
20797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
20798     return 0;
20799   }
20800   {
20801     try {
20802       result = (Dali::Device::Subclass::Type)arg1->GetDeviceSubclass();
20803     } CALL_CATCH_EXCEPTION(0);
20804   }
20805
20806   jresult = (int)result;
20807   return jresult;
20808 }
20809
20810 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Raise(void * jarg1) {
20811   Dali::Actor arg1 ;
20812   Dali::Actor *argp1 ;
20813
20814   argp1 = (Dali::Actor *)jarg1;
20815   if (!argp1) {
20816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
20817     return ;
20818   }
20819   arg1 = *argp1;
20820   {
20821     try {
20822       arg1.Raise();
20823     } CALL_CATCH_EXCEPTION();
20824   }
20825
20826 }
20827
20828
20829 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Lower(void * jarg1) {
20830   Dali::Actor arg1 ;
20831   Dali::Actor *argp1 ;
20832
20833   argp1 = (Dali::Actor *)jarg1;
20834   if (!argp1) {
20835     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
20836     return ;
20837   }
20838   arg1 = *argp1;
20839   {
20840     try {
20841       arg1.Lower();
20842     } CALL_CATCH_EXCEPTION();
20843   }
20844
20845 }
20846
20847
20848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseToTop(void * jarg1) {
20849   Dali::Actor arg1 ;
20850   Dali::Actor *argp1 ;
20851
20852   argp1 = (Dali::Actor *)jarg1;
20853   if (!argp1) {
20854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
20855     return ;
20856   }
20857   arg1 = *argp1;
20858   {
20859     try {
20860       arg1.RaiseToTop();
20861     } CALL_CATCH_EXCEPTION();
20862   }
20863
20864 }
20865
20866
20867 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerToBottom(void * jarg1) {
20868   Dali::Actor arg1 ;
20869   Dali::Actor *argp1 ;
20870
20871   argp1 = (Dali::Actor *)jarg1;
20872   if (!argp1) {
20873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
20874     return ;
20875   }
20876   arg1 = *argp1;
20877   {
20878     try {
20879       arg1.LowerToBottom();
20880     } CALL_CATCH_EXCEPTION();
20881   }
20882
20883 }
20884
20885 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseAbove(void * jarg1, void * jarg2) {
20886   Dali::Actor arg1 ;
20887   Dali::Actor arg2 ;
20888   Dali::Actor *argp1 ;
20889   Dali::Actor *argp2 ;
20890
20891   argp1 = (Dali::Actor *)jarg1;
20892   if (!argp1) {
20893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
20894     return ;
20895   }
20896   arg1 = *argp1;
20897   argp2 = (Dali::Actor *)jarg2;
20898   if (!argp2) {
20899     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
20900     return ;
20901   }
20902   arg2 = *argp2;
20903   {
20904     try {
20905       arg1.RaiseAbove(arg2);
20906     } CALL_CATCH_EXCEPTION();
20907   }
20908
20909 }
20910
20911
20912 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerBelow(void * jarg1, void * jarg2) {
20913   Dali::Actor arg1 ;
20914   Dali::Actor arg2 ;
20915   Dali::Actor *argp1 ;
20916   Dali::Actor *argp2 ;
20917
20918   argp1 = (Dali::Actor *)jarg1;
20919   if (!argp1) {
20920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
20921     return ;
20922   }
20923   arg1 = *argp1;
20924   argp2 = (Dali::Actor *)jarg2;
20925   if (!argp2) {
20926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
20927     return ;
20928   }
20929   arg2 = *argp2;
20930   {
20931     try {
20932       arg1.LowerBelow(arg2);
20933     } CALL_CATCH_EXCEPTION();
20934   }
20935
20936 }
20937
20938
20939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisibilityChangedSignal(void * jarg1) {
20940   void * jresult ;
20941   Dali::Actor arg1 ;
20942   Dali::Actor *argp1 ;
20943   Dali::DevelActor::VisibilityChangedSignalType *result = 0 ;
20944
20945   argp1 = (Dali::Actor *)jarg1;
20946   if (!argp1) {
20947     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
20948     return 0;
20949   }
20950   arg1 = *argp1;
20951   {
20952     try {
20953       result = (Dali::DevelActor::VisibilityChangedSignalType *) &Dali::DevelActor::VisibilityChangedSignal(arg1);
20954     } CALL_CATCH_EXCEPTION(0);
20955   }
20956
20957   jresult = (void *)result;
20958   return jresult;
20959 }
20960
20961
20962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutDirectionChangedSignal(void * jarg1) {
20963   void * jresult ;
20964   Dali::Actor *arg1 ;
20965   Dali::Actor::LayoutDirectionChangedSignalType *result = 0 ;
20966
20967   arg1 = (Dali::Actor *)jarg1;
20968   {
20969     try {
20970       result = (Dali::Actor::LayoutDirectionChangedSignalType *) &(arg1)->LayoutDirectionChangedSignal();
20971     } CALL_CATCH_EXCEPTION(0);
20972   }
20973
20974   jresult = (void *)result;
20975   return jresult;
20976 }
20977
20978
20979 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_get() {
20980   int jresult ;
20981   int result;
20982
20983   result = (int)Dali::Actor::Property::PARENT_ORIGIN;
20984   jresult = (int)result;
20985   return jresult;
20986 }
20987
20988
20989 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_X_get() {
20990   int jresult ;
20991   int result;
20992
20993   result = (int)Dali::Actor::Property::PARENT_ORIGIN_X;
20994   jresult = (int)result;
20995   return jresult;
20996 }
20997
20998
20999 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Y_get() {
21000   int jresult ;
21001   int result;
21002
21003   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Y;
21004   jresult = (int)result;
21005   return jresult;
21006 }
21007
21008
21009 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Z_get() {
21010   int jresult ;
21011   int result;
21012
21013   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Z;
21014   jresult = (int)result;
21015   return jresult;
21016 }
21017
21018
21019 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_get() {
21020   int jresult ;
21021   int result;
21022
21023   result = (int)Dali::Actor::Property::ANCHOR_POINT;
21024   jresult = (int)result;
21025   return jresult;
21026 }
21027
21028
21029 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_X_get() {
21030   int jresult ;
21031   int result;
21032
21033   result = (int)Dali::Actor::Property::ANCHOR_POINT_X;
21034   jresult = (int)result;
21035   return jresult;
21036 }
21037
21038
21039 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Y_get() {
21040   int jresult ;
21041   int result;
21042
21043   result = (int)Dali::Actor::Property::ANCHOR_POINT_Y;
21044   jresult = (int)result;
21045   return jresult;
21046 }
21047
21048
21049 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Z_get() {
21050   int jresult ;
21051   int result;
21052
21053   result = (int)Dali::Actor::Property::ANCHOR_POINT_Z;
21054   jresult = (int)result;
21055   return jresult;
21056 }
21057
21058
21059 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_get() {
21060   int jresult ;
21061   int result;
21062
21063   result = (int)Dali::Actor::Property::SIZE;
21064   jresult = (int)result;
21065   return jresult;
21066 }
21067
21068
21069 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_WIDTH_get() {
21070   int jresult ;
21071   int result;
21072
21073   result = (int)Dali::Actor::Property::SIZE_WIDTH;
21074   jresult = (int)result;
21075   return jresult;
21076 }
21077
21078
21079 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_HEIGHT_get() {
21080   int jresult ;
21081   int result;
21082
21083   result = (int)Dali::Actor::Property::SIZE_HEIGHT;
21084   jresult = (int)result;
21085   return jresult;
21086 }
21087
21088
21089 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_DEPTH_get() {
21090   int jresult ;
21091   int result;
21092
21093   result = (int)Dali::Actor::Property::SIZE_DEPTH;
21094   jresult = (int)result;
21095   return jresult;
21096 }
21097
21098
21099 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_get() {
21100   int jresult ;
21101   int result;
21102
21103   result = (int)Dali::Actor::Property::POSITION;
21104   jresult = (int)result;
21105   return jresult;
21106 }
21107
21108
21109 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_X_get() {
21110   int jresult ;
21111   int result;
21112
21113   result = (int)Dali::Actor::Property::POSITION_X;
21114   jresult = (int)result;
21115   return jresult;
21116 }
21117
21118
21119 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Y_get() {
21120   int jresult ;
21121   int result;
21122
21123   result = (int)Dali::Actor::Property::POSITION_Y;
21124   jresult = (int)result;
21125   return jresult;
21126 }
21127
21128
21129 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Z_get() {
21130   int jresult ;
21131   int result;
21132
21133   result = (int)Dali::Actor::Property::POSITION_Z;
21134   jresult = (int)result;
21135   return jresult;
21136 }
21137
21138
21139 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_get() {
21140   int jresult ;
21141   int result;
21142
21143   result = (int)Dali::Actor::Property::WORLD_POSITION;
21144   jresult = (int)result;
21145   return jresult;
21146 }
21147
21148
21149 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_X_get() {
21150   int jresult ;
21151   int result;
21152
21153   result = (int)Dali::Actor::Property::WORLD_POSITION_X;
21154   jresult = (int)result;
21155   return jresult;
21156 }
21157
21158
21159 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Y_get() {
21160   int jresult ;
21161   int result;
21162
21163   result = (int)Dali::Actor::Property::WORLD_POSITION_Y;
21164   jresult = (int)result;
21165   return jresult;
21166 }
21167
21168
21169 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Z_get() {
21170   int jresult ;
21171   int result;
21172
21173   result = (int)Dali::Actor::Property::WORLD_POSITION_Z;
21174   jresult = (int)result;
21175   return jresult;
21176 }
21177
21178
21179 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ORIENTATION_get() {
21180   int jresult ;
21181   int result;
21182
21183   result = (int)Dali::Actor::Property::ORIENTATION;
21184   jresult = (int)result;
21185   return jresult;
21186 }
21187
21188
21189 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_ORIENTATION_get() {
21190   int jresult ;
21191   int result;
21192
21193   result = (int)Dali::Actor::Property::WORLD_ORIENTATION;
21194   jresult = (int)result;
21195   return jresult;
21196 }
21197
21198
21199 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_get() {
21200   int jresult ;
21201   int result;
21202
21203   result = (int)Dali::Actor::Property::SCALE;
21204   jresult = (int)result;
21205   return jresult;
21206 }
21207
21208
21209 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_X_get() {
21210   int jresult ;
21211   int result;
21212
21213   result = (int)Dali::Actor::Property::SCALE_X;
21214   jresult = (int)result;
21215   return jresult;
21216 }
21217
21218
21219 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Y_get() {
21220   int jresult ;
21221   int result;
21222
21223   result = (int)Dali::Actor::Property::SCALE_Y;
21224   jresult = (int)result;
21225   return jresult;
21226 }
21227
21228
21229 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Z_get() {
21230   int jresult ;
21231   int result;
21232
21233   result = (int)Dali::Actor::Property::SCALE_Z;
21234   jresult = (int)result;
21235   return jresult;
21236 }
21237
21238
21239 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_SCALE_get() {
21240   int jresult ;
21241   int result;
21242
21243   result = (int)Dali::Actor::Property::WORLD_SCALE;
21244   jresult = (int)result;
21245   return jresult;
21246 }
21247
21248
21249 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_VISIBLE_get() {
21250   int jresult ;
21251   int result;
21252
21253   result = (int)Dali::Actor::Property::VISIBLE;
21254   jresult = (int)result;
21255   return jresult;
21256 }
21257
21258
21259 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_get() {
21260   int jresult ;
21261   int result;
21262
21263   result = (int)Dali::Actor::Property::COLOR;
21264   jresult = (int)result;
21265   return jresult;
21266 }
21267
21268
21269 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_RED_get() {
21270   int jresult ;
21271   int result;
21272
21273   result = (int)Dali::Actor::Property::COLOR_RED;
21274   jresult = (int)result;
21275   return jresult;
21276 }
21277
21278
21279 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_GREEN_get() {
21280   int jresult ;
21281   int result;
21282
21283   result = (int)Dali::Actor::Property::COLOR_GREEN;
21284   jresult = (int)result;
21285   return jresult;
21286 }
21287
21288
21289 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_BLUE_get() {
21290   int jresult ;
21291   int result;
21292
21293   result = (int)Dali::Actor::Property::COLOR_BLUE;
21294   jresult = (int)result;
21295   return jresult;
21296 }
21297
21298
21299 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_ALPHA_get() {
21300   int jresult ;
21301   int result;
21302
21303   result = (int)Dali::Actor::Property::COLOR_ALPHA;
21304   jresult = (int)result;
21305   return jresult;
21306 }
21307
21308
21309 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_COLOR_get() {
21310   int jresult ;
21311   int result;
21312
21313   result = (int)Dali::Actor::Property::WORLD_COLOR;
21314   jresult = (int)result;
21315   return jresult;
21316 }
21317
21318
21319 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_MATRIX_get() {
21320   int jresult ;
21321   int result;
21322
21323   result = (int)Dali::Actor::Property::WORLD_MATRIX;
21324   jresult = (int)result;
21325   return jresult;
21326 }
21327
21328
21329 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_NAME_get() {
21330   int jresult ;
21331   int result;
21332
21333   result = (int)Dali::Actor::Property::NAME;
21334   jresult = (int)result;
21335   return jresult;
21336 }
21337
21338
21339 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SENSITIVE_get() {
21340   int jresult ;
21341   int result;
21342
21343   result = (int)Dali::Actor::Property::SENSITIVE;
21344   jresult = (int)result;
21345   return jresult;
21346 }
21347
21348
21349 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_LEAVE_REQUIRED_get() {
21350   int jresult ;
21351   int result;
21352
21353   result = (int)Dali::Actor::Property::LEAVE_REQUIRED;
21354   jresult = (int)result;
21355   return jresult;
21356 }
21357
21358
21359 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_ORIENTATION_get() {
21360   int jresult ;
21361   int result;
21362
21363   result = (int)Dali::Actor::Property::INHERIT_ORIENTATION;
21364   jresult = (int)result;
21365   return jresult;
21366 }
21367
21368
21369 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_SCALE_get() {
21370   int jresult ;
21371   int result;
21372
21373   result = (int)Dali::Actor::Property::INHERIT_SCALE;
21374   jresult = (int)result;
21375   return jresult;
21376 }
21377
21378
21379 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_MODE_get() {
21380   int jresult ;
21381   int result;
21382
21383   result = (int)Dali::Actor::Property::COLOR_MODE;
21384   jresult = (int)result;
21385   return jresult;
21386 }
21387
21388
21389 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_DRAW_MODE_get() {
21390   int jresult ;
21391   int result;
21392
21393   result = (int)Dali::Actor::Property::DRAW_MODE;
21394   jresult = (int)result;
21395   return jresult;
21396 }
21397
21398
21399 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_MODE_FACTOR_get() {
21400   int jresult ;
21401   int result;
21402
21403   result = (int)Dali::Actor::Property::SIZE_MODE_FACTOR;
21404   jresult = (int)result;
21405   return jresult;
21406 }
21407
21408
21409 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_RESIZE_POLICY_get() {
21410   int jresult ;
21411   int result;
21412
21413   result = (int)Dali::Actor::Property::WIDTH_RESIZE_POLICY;
21414   jresult = (int)result;
21415   return jresult;
21416 }
21417
21418
21419 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_RESIZE_POLICY_get() {
21420   int jresult ;
21421   int result;
21422
21423   result = (int)Dali::Actor::Property::HEIGHT_RESIZE_POLICY;
21424   jresult = (int)result;
21425   return jresult;
21426 }
21427
21428
21429 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_SCALE_POLICY_get() {
21430   int jresult ;
21431   int result;
21432
21433   result = (int)Dali::Actor::Property::SIZE_SCALE_POLICY;
21434   jresult = (int)result;
21435   return jresult;
21436 }
21437
21438
21439 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_FOR_HEIGHT_get() {
21440   int jresult ;
21441   int result;
21442
21443   result = (int)Dali::Actor::Property::WIDTH_FOR_HEIGHT;
21444   jresult = (int)result;
21445   return jresult;
21446 }
21447
21448
21449 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_FOR_WIDTH_get() {
21450   int jresult ;
21451   int result;
21452
21453   result = (int)Dali::Actor::Property::HEIGHT_FOR_WIDTH;
21454   jresult = (int)result;
21455   return jresult;
21456 }
21457
21458
21459 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PADDING_get() {
21460   int jresult ;
21461   int result;
21462
21463   result = (int)Dali::Actor::Property::PADDING;
21464   jresult = (int)result;
21465   return jresult;
21466 }
21467
21468
21469 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MINIMUM_SIZE_get() {
21470   int jresult ;
21471   int result;
21472
21473   result = (int)Dali::Actor::Property::MINIMUM_SIZE;
21474   jresult = (int)result;
21475   return jresult;
21476 }
21477
21478
21479 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MAXIMUM_SIZE_get() {
21480   int jresult ;
21481   int result;
21482
21483   result = (int)Dali::Actor::Property::MAXIMUM_SIZE;
21484   jresult = (int)result;
21485   return jresult;
21486 }
21487
21488
21489 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_POSITION_get() {
21490   int jresult ;
21491   int result;
21492
21493   result = (int)Dali::Actor::Property::INHERIT_POSITION;
21494   jresult = (int)result;
21495   return jresult;
21496 }
21497
21498
21499 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CLIPPING_MODE_get() {
21500   int jresult ;
21501   int result;
21502
21503   result = (int)Dali::Actor::Property::CLIPPING_MODE;
21504   jresult = (int)result;
21505   return jresult;
21506 }
21507
21508 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_OPACITY_get() {
21509
21510   return Dali::Actor::Property::OPACITY;
21511 }
21512
21513 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_SCREEN_POSITION_get() {
21514
21515   return Dali::Actor::Property::SCREEN_POSITION;
21516 }
21517
21518 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_POSITION_USES_ANCHOR_POINT_get() {
21519
21520   return Dali::Actor::Property::POSITION_USES_ANCHOR_POINT;
21521 }
21522
21523 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_INHERIT_LAYOUT_DIRECTION_get() {
21524   return Dali::Actor::Property::INHERIT_LAYOUT_DIRECTION;
21525 }
21526
21527 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_LAYOUT_DIRECTION_get() {
21528   return Dali::Actor::Property::LAYOUT_DIRECTION;
21529 }
21530
21531 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor_Property() {
21532   void * jresult ;
21533   Dali::Actor::Property *result = 0 ;
21534
21535   {
21536     try {
21537       result = (Dali::Actor::Property *)new Dali::Actor::Property();
21538     } CALL_CATCH_EXCEPTION(0);
21539   }
21540
21541   jresult = (void *)result;
21542   return jresult;
21543 }
21544
21545
21546 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor_Property(void * jarg1) {
21547   Dali::Actor::Property *arg1 = (Dali::Actor::Property *) 0 ;
21548
21549   arg1 = (Dali::Actor::Property *)jarg1;
21550   {
21551     try {
21552       delete arg1;
21553     } CALL_CATCH_EXCEPTION();
21554   }
21555
21556 }
21557
21558
21559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_0() {
21560   void * jresult ;
21561   Dali::Actor *result = 0 ;
21562
21563   {
21564     try {
21565       result = (Dali::Actor *)new Dali::Actor();
21566     } CALL_CATCH_EXCEPTION(0);
21567   }
21568
21569   jresult = (void *)result;
21570   return jresult;
21571 }
21572
21573
21574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_New() {
21575   void * jresult ;
21576   Dali::Actor result;
21577
21578   {
21579     try {
21580       result = Dali::Actor::New();
21581     } CALL_CATCH_EXCEPTION(0);
21582   }
21583
21584   jresult = new Dali::Actor((const Dali::Actor &)result);
21585   return jresult;
21586 }
21587
21588
21589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_DownCast(void * jarg1) {
21590   void * jresult ;
21591   Dali::BaseHandle arg1 ;
21592   Dali::BaseHandle *argp1 ;
21593   Dali::Actor result;
21594
21595   argp1 = (Dali::BaseHandle *)jarg1;
21596   if (!argp1) {
21597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
21598     return 0;
21599   }
21600   arg1 = *argp1;
21601   {
21602     try {
21603       result = Dali::Actor::DownCast(arg1);
21604     } CALL_CATCH_EXCEPTION(0);
21605   }
21606
21607   jresult = new Dali::Actor((const Dali::Actor &)result);
21608   return jresult;
21609 }
21610
21611
21612 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor(void * jarg1) {
21613   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21614
21615   arg1 = (Dali::Actor *)jarg1;
21616   {
21617     try {
21618       delete arg1;
21619     } CALL_CATCH_EXCEPTION();
21620   }
21621
21622 }
21623
21624
21625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_1(void * jarg1) {
21626   void * jresult ;
21627   Dali::Actor *arg1 = 0 ;
21628   Dali::Actor *result = 0 ;
21629
21630   arg1 = (Dali::Actor *)jarg1;
21631   if (!arg1) {
21632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
21633     return 0;
21634   }
21635   {
21636     try {
21637       result = (Dali::Actor *)new Dali::Actor((Dali::Actor const &)*arg1);
21638     } CALL_CATCH_EXCEPTION(0);
21639   }
21640
21641   jresult = (void *)result;
21642   return jresult;
21643 }
21644
21645
21646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_Assign(void * jarg1, void * jarg2) {
21647   void * jresult ;
21648   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21649   Dali::Actor *arg2 = 0 ;
21650   Dali::Actor *result = 0 ;
21651
21652   arg1 = (Dali::Actor *)jarg1;
21653   arg2 = (Dali::Actor *)jarg2;
21654   if (!arg2) {
21655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
21656     return 0;
21657   }
21658   {
21659     try {
21660       result = (Dali::Actor *) &(arg1)->operator =((Dali::Actor const &)*arg2);
21661     } CALL_CATCH_EXCEPTION(0);
21662   }
21663
21664   jresult = (void *)result;
21665   return jresult;
21666 }
21667
21668
21669 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Actor_GetName(void * jarg1) {
21670   char * jresult ;
21671   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21672   std::string *result = 0 ;
21673   std::string name = "";
21674
21675   arg1 = (Dali::Actor *)jarg1;
21676   {
21677     try {
21678       name = ((Dali::Actor const *)arg1)->GetProperty< std::string >( Dali::Actor::Property::NAME );
21679       result = (std::string *) &name;
21680       jresult = SWIG_csharp_string_callback(result->c_str());
21681     } CALL_CATCH_EXCEPTION(0);
21682   }
21683   return jresult;
21684 }
21685
21686
21687 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetName(void * jarg1, char * jarg2) {
21688   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21689   std::string *arg2 = 0 ;
21690
21691   arg1 = (Dali::Actor *)jarg1;
21692   if (!jarg2) {
21693     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
21694     return ;
21695   }
21696   std::string arg2_str(jarg2);
21697   arg2 = &arg2_str;
21698   {
21699     try {
21700       (arg1)->SetProperty( Dali::Actor::Property::NAME, (std::string const &)*arg2);
21701     } CALL_CATCH_EXCEPTION();
21702   }
21703
21704
21705   //argout typemap for const std::string&
21706
21707 }
21708
21709
21710 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetId(void * jarg1) {
21711   unsigned int jresult ;
21712   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21713   unsigned int result;
21714
21715   arg1 = (Dali::Actor *)jarg1;
21716
21717   if(!arg1) {
21718     DALI_LOG_ERROR("[ERROR] actor is null! return -1");
21719     return -1;
21720   }
21721
21722   {
21723     try {
21724       result = (unsigned int)((Dali::Actor const *)arg1)->GetProperty< int >( Actor::Property::ID );
21725     } CALL_CATCH_EXCEPTION(0);
21726   }
21727
21728   jresult = result;
21729   return jresult;
21730 }
21731
21732
21733 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsRoot(void * jarg1) {
21734   unsigned int jresult ;
21735   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21736   bool result;
21737
21738   arg1 = (Dali::Actor *)jarg1;
21739   {
21740     try {
21741       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::IS_ROOT );
21742     } CALL_CATCH_EXCEPTION(0);
21743   }
21744
21745   jresult = result;
21746   return jresult;
21747 }
21748
21749
21750 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_OnStage(void * jarg1) {
21751   unsigned int jresult ;
21752   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21753   bool result;
21754
21755   arg1 = (Dali::Actor *)jarg1;
21756   {
21757     try {
21758       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::CONNECTED_TO_SCENE );
21759     } CALL_CATCH_EXCEPTION(0);
21760   }
21761
21762   jresult = result;
21763   return jresult;
21764 }
21765
21766
21767 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsLayer(void * jarg1) {
21768   unsigned int jresult ;
21769   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21770   bool result;
21771
21772   arg1 = (Dali::Actor *)jarg1;
21773   {
21774     try {
21775       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::IS_LAYER );
21776     } CALL_CATCH_EXCEPTION(0);
21777   }
21778
21779   jresult = result;
21780   return jresult;
21781 }
21782
21783
21784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetLayer(void * jarg1) {
21785   void * jresult ;
21786   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21787   Dali::Layer result;
21788
21789   arg1 = (Dali::Actor *)jarg1;
21790   {
21791     try {
21792       result = (arg1)->GetLayer();
21793     } CALL_CATCH_EXCEPTION(0);
21794   }
21795
21796   jresult = new Dali::Layer((const Dali::Layer &)result);
21797   return jresult;
21798 }
21799
21800
21801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Add(void * jarg1, void * jarg2) {
21802   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21803   Dali::Actor arg2 ;
21804   Dali::Actor *argp2 ;
21805
21806   arg1 = (Dali::Actor *)jarg1;
21807   argp2 = (Dali::Actor *)jarg2;
21808   if (!argp2) {
21809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
21810     return ;
21811   }
21812   arg2 = *argp2;
21813   {
21814     try {
21815       (arg1)->Add(arg2);
21816     } CALL_CATCH_EXCEPTION();
21817   }
21818
21819 }
21820
21821
21822 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Remove(void * jarg1, void * jarg2) {
21823   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21824   Dali::Actor arg2 ;
21825   Dali::Actor *argp2 ;
21826
21827   arg1 = (Dali::Actor *)jarg1;
21828   argp2 = (Dali::Actor *)jarg2;
21829   if (!argp2) {
21830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
21831     return ;
21832   }
21833   arg2 = *argp2;
21834   {
21835     try {
21836       (arg1)->Remove(arg2);
21837     } CALL_CATCH_EXCEPTION();
21838   }
21839
21840 }
21841
21842
21843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Unparent(void * jarg1) {
21844   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21845
21846   arg1 = (Dali::Actor *)jarg1;
21847   {
21848     try {
21849       (arg1)->Unparent();
21850     } CALL_CATCH_EXCEPTION();
21851   }
21852
21853 }
21854
21855
21856 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetChildCount(void * jarg1) {
21857   unsigned int jresult ;
21858   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21859   unsigned int result;
21860
21861   arg1 = (Dali::Actor *)jarg1;
21862   {
21863     try {
21864       result = (unsigned int)((Dali::Actor const *)arg1)->GetChildCount();
21865     } CALL_CATCH_EXCEPTION(0);
21866   }
21867
21868   jresult = result;
21869   return jresult;
21870 }
21871
21872
21873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetChildAt(void * jarg1, unsigned int jarg2) {
21874   void * jresult ;
21875   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21876   unsigned int arg2 ;
21877   Dali::Actor result;
21878
21879   arg1 = (Dali::Actor *)jarg1;
21880   arg2 = (unsigned int)jarg2;
21881   {
21882     try {
21883       result = ((Dali::Actor const *)arg1)->GetChildAt(arg2);
21884     } CALL_CATCH_EXCEPTION(0);
21885   }
21886
21887   jresult = new Dali::Actor((const Dali::Actor &)result);
21888   return jresult;
21889 }
21890
21891
21892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildByName(void * jarg1, char * jarg2) {
21893   void * jresult ;
21894   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21895   std::string *arg2 = 0 ;
21896   Dali::Actor result;
21897
21898   arg1 = (Dali::Actor *)jarg1;
21899   if (!jarg2) {
21900     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
21901     return 0;
21902   }
21903   std::string arg2_str(jarg2);
21904   arg2 = &arg2_str;
21905   {
21906     try {
21907       result = (arg1)->FindChildByName((std::string const &)*arg2);
21908     } CALL_CATCH_EXCEPTION(0);
21909   }
21910
21911   jresult = new Dali::Actor((const Dali::Actor &)result);
21912
21913   //argout typemap for const std::string&
21914
21915   return jresult;
21916 }
21917
21918
21919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildById(void * jarg1, unsigned int jarg2) {
21920   void * jresult ;
21921   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21922   unsigned int arg2 ;
21923   Dali::Actor result;
21924
21925   arg1 = (Dali::Actor *)jarg1;
21926   arg2 = (unsigned int)jarg2;
21927   {
21928     try {
21929       result = (arg1)->FindChildById(arg2);
21930     } CALL_CATCH_EXCEPTION(0);
21931   }
21932
21933   jresult = new Dali::Actor((const Dali::Actor &)result);
21934   return jresult;
21935 }
21936
21937
21938 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetParent(void * jarg1) {
21939   void * jresult ;
21940   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21941   Dali::Actor result;
21942
21943   arg1 = (Dali::Actor *)jarg1;
21944   {
21945     try {
21946       result = ((Dali::Actor const *)arg1)->GetParent();
21947     } CALL_CATCH_EXCEPTION(0);
21948   }
21949
21950   jresult = new Dali::Actor((const Dali::Actor &)result);
21951   return jresult;
21952 }
21953
21954
21955 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetParentOrigin(void * jarg1, void * jarg2) {
21956   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21957   Dali::Vector3 *arg2 = 0 ;
21958
21959   arg1 = (Dali::Actor *)jarg1;
21960   arg2 = (Dali::Vector3 *)jarg2;
21961   if (!arg2) {
21962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
21963     return ;
21964   }
21965   {
21966     try {
21967       (arg1)->SetProperty( Actor::Property::PARENT_ORIGIN,(Dali::Vector3 const &)*arg2);
21968     } CALL_CATCH_EXCEPTION();
21969   }
21970
21971 }
21972
21973
21974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentParentOrigin(void * jarg1) {
21975   void * jresult ;
21976   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21977   Dali::Vector3 result;
21978
21979   arg1 = (Dali::Actor *)jarg1;
21980   {
21981     try {
21982       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::PARENT_ORIGIN );
21983     } CALL_CATCH_EXCEPTION(0);
21984   }
21985
21986   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
21987   return jresult;
21988 }
21989
21990
21991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetAnchorPoint(void * jarg1, void * jarg2) {
21992   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21993   Dali::Vector3 *arg2 = 0 ;
21994
21995   arg1 = (Dali::Actor *)jarg1;
21996   arg2 = (Dali::Vector3 *)jarg2;
21997   if (!arg2) {
21998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
21999     return ;
22000   }
22001   {
22002     try {
22003       (arg1)->SetProperty( Actor::Property::ANCHOR_POINT,(Dali::Vector3 const &)*arg2);
22004     } CALL_CATCH_EXCEPTION();
22005   }
22006
22007 }
22008
22009
22010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentAnchorPoint(void * jarg1) {
22011   void * jresult ;
22012   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22013   Dali::Vector3 result;
22014
22015   arg1 = (Dali::Actor *)jarg1;
22016   {
22017     try {
22018       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::ANCHOR_POINT );
22019     } CALL_CATCH_EXCEPTION(0);
22020   }
22021
22022   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
22023   return jresult;
22024 }
22025
22026
22027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_0(void * jarg1, float jarg2, float jarg3) {
22028   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22029   float arg2 ;
22030   float arg3 ;
22031
22032   arg1 = (Dali::Actor *)jarg1;
22033   arg2 = (float)jarg2;
22034   arg3 = (float)jarg3;
22035   {
22036     try {
22037       (arg1)->SetProperty( Actor::Property::SIZE, Dali::Vector2(arg2,arg3) );
22038     } CALL_CATCH_EXCEPTION();
22039   }
22040
22041 }
22042
22043
22044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
22045   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22046   float arg2 ;
22047   float arg3 ;
22048   float arg4 ;
22049
22050   arg1 = (Dali::Actor *)jarg1;
22051   arg2 = (float)jarg2;
22052   arg3 = (float)jarg3;
22053   arg4 = (float)jarg4;
22054   {
22055     try {
22056       (arg1)->SetProperty( Actor::Property::SIZE, Dali::Vector3(arg2,arg3,arg4) );
22057     } CALL_CATCH_EXCEPTION();
22058   }
22059
22060 }
22061
22062
22063 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_2(void * jarg1, void * jarg2) {
22064   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22065   Dali::Vector2 *arg2 = 0 ;
22066
22067   arg1 = (Dali::Actor *)jarg1;
22068   arg2 = (Dali::Vector2 *)jarg2;
22069   if (!arg2) {
22070     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
22071     return ;
22072   }
22073   {
22074     try {
22075       (arg1)->SetProperty( Actor::Property::SIZE, (Dali::Vector2 const &)*arg2);
22076     } CALL_CATCH_EXCEPTION();
22077   }
22078
22079 }
22080
22081
22082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_3(void * jarg1, void * jarg2) {
22083   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22084   Dali::Vector3 *arg2 = 0 ;
22085
22086   arg1 = (Dali::Actor *)jarg1;
22087   arg2 = (Dali::Vector3 *)jarg2;
22088   if (!arg2) {
22089     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
22090     return ;
22091   }
22092   {
22093     try {
22094       (arg1)->SetProperty( Actor::Property::SIZE, (Dali::Vector3 const &)*arg2);
22095     } CALL_CATCH_EXCEPTION();
22096   }
22097
22098 }
22099
22100
22101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetTargetSize(void * jarg1) {
22102   void * jresult ;
22103   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22104   Dali::Vector3 result;
22105
22106   arg1 = (Dali::Actor *)jarg1;
22107   {
22108     try {
22109       result = ((Dali::Actor const *)arg1)->GetTargetSize();
22110     } CALL_CATCH_EXCEPTION(0);
22111   }
22112
22113   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
22114   return jresult;
22115 }
22116
22117
22118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentSize(void * jarg1) {
22119   void * jresult ;
22120   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22121   Dali::Vector3 result;
22122
22123   arg1 = (Dali::Actor *)jarg1;
22124   {
22125     try {
22126       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::SIZE );
22127     } CALL_CATCH_EXCEPTION(0);
22128   }
22129
22130   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
22131   return jresult;
22132 }
22133
22134
22135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetNaturalSize(void * jarg1) {
22136   void * jresult ;
22137   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22138   Dali::Vector3 result;
22139
22140   arg1 = (Dali::Actor *)jarg1;
22141   {
22142     try {
22143       result = ((Dali::Actor const *)arg1)->GetNaturalSize();
22144     } CALL_CATCH_EXCEPTION(0);
22145   }
22146
22147   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
22148   return jresult;
22149 }
22150
22151
22152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_0(void * jarg1, float jarg2, float jarg3) {
22153   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22154   float arg2 ;
22155   float arg3 ;
22156
22157   arg1 = (Dali::Actor *)jarg1;
22158   arg2 = (float)jarg2;
22159   arg3 = (float)jarg3;
22160   {
22161     try {
22162       (arg1)->SetProperty( Actor::Property::POSITION, Dali::Vector2( arg2, arg3 ) );
22163     } CALL_CATCH_EXCEPTION();
22164   }
22165
22166 }
22167
22168
22169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
22170   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22171   float arg2 ;
22172   float arg3 ;
22173   float arg4 ;
22174
22175   arg1 = (Dali::Actor *)jarg1;
22176   arg2 = (float)jarg2;
22177   arg3 = (float)jarg3;
22178   arg4 = (float)jarg4;
22179   {
22180     try {
22181       (arg1)->SetProperty( Actor::Property::POSITION, Dali::Vector3( arg2, arg3, arg4 ) );
22182     } CALL_CATCH_EXCEPTION();
22183   }
22184
22185 }
22186
22187
22188 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_2(void * jarg1, void * jarg2) {
22189   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22190   Dali::Vector3 *arg2 = 0 ;
22191
22192   arg1 = (Dali::Actor *)jarg1;
22193   arg2 = (Dali::Vector3 *)jarg2;
22194   if (!arg2) {
22195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
22196     return ;
22197   }
22198   {
22199     try {
22200       (arg1)->SetProperty( Actor::Property::POSITION, (Dali::Vector3 const &)*arg2 );
22201     } CALL_CATCH_EXCEPTION();
22202   }
22203
22204 }
22205
22206
22207 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetX(void * jarg1, float jarg2) {
22208   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22209   float arg2 ;
22210
22211   arg1 = (Dali::Actor *)jarg1;
22212   arg2 = (float)jarg2;
22213   {
22214     try {
22215       (arg1)->SetProperty( Actor::Property::POSITION_X, (arg2) );
22216     } CALL_CATCH_EXCEPTION();
22217   }
22218
22219 }
22220
22221
22222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetY(void * jarg1, float jarg2) {
22223   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22224   float arg2 ;
22225
22226   arg1 = (Dali::Actor *)jarg1;
22227   arg2 = (float)jarg2;
22228   {
22229     try {
22230       (arg1)->SetProperty( Actor::Property::POSITION_Y, arg2 );
22231     } CALL_CATCH_EXCEPTION();
22232   }
22233
22234 }
22235
22236
22237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetZ(void * jarg1, float jarg2) {
22238   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22239   float arg2 ;
22240
22241   arg1 = (Dali::Actor *)jarg1;
22242   arg2 = (float)jarg2;
22243   {
22244     try {
22245       (arg1)->SetProperty( Actor::Property::POSITION_Z, arg2 );
22246     } CALL_CATCH_EXCEPTION();
22247   }
22248
22249 }
22250
22251
22252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_TranslateBy(void * jarg1, void * jarg2) {
22253   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22254   Dali::Vector3 *arg2 = 0 ;
22255
22256   arg1 = (Dali::Actor *)jarg1;
22257   arg2 = (Dali::Vector3 *)jarg2;
22258   if (!arg2) {
22259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
22260     return ;
22261   }
22262   {
22263     try {
22264       (arg1)->TranslateBy((Dali::Vector3 const &)*arg2);
22265     } CALL_CATCH_EXCEPTION();
22266   }
22267
22268 }
22269
22270
22271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentPosition(void * jarg1) {
22272   void * jresult ;
22273   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22274   Dali::Vector3 result;
22275
22276   arg1 = (Dali::Actor *)jarg1;
22277   {
22278     try {
22279       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::POSITION );
22280     } CALL_CATCH_EXCEPTION(0);
22281   }
22282
22283   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
22284   return jresult;
22285 }
22286
22287
22288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldPosition(void * jarg1) {
22289   void * jresult ;
22290   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22291   Dali::Vector3 result;
22292
22293   arg1 = (Dali::Actor *)jarg1;
22294   {
22295     try {
22296       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::WORLD_POSITION );
22297     } CALL_CATCH_EXCEPTION(0);
22298   }
22299
22300   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
22301   return jresult;
22302 }
22303
22304
22305 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritPosition(void * jarg1, unsigned int jarg2) {
22306   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22307   bool arg2 ;
22308
22309   arg1 = (Dali::Actor *)jarg1;
22310   arg2 = jarg2 ? true : false;
22311   {
22312     try {
22313       (arg1)->SetProperty(Dali::Actor::Property::INHERIT_POSITION, arg2);
22314     } CALL_CATCH_EXCEPTION();
22315   }
22316
22317 }
22318
22319
22320 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsPositionInherited(void * jarg1) {
22321   unsigned int jresult ;
22322   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22323   bool result;
22324
22325   arg1 = (Dali::Actor *)jarg1;
22326   {
22327     try {
22328       result = (bool)((Dali::Actor const *)arg1)->GetProperty<bool>(Dali::Actor::Property::INHERIT_POSITION);
22329     } CALL_CATCH_EXCEPTION(0);
22330   }
22331
22332   jresult = result;
22333   return jresult;
22334 }
22335
22336
22337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
22338   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22339   Dali::Degree *arg2 = 0 ;
22340   Dali::Vector3 *arg3 = 0 ;
22341
22342   arg1 = (Dali::Actor *)jarg1;
22343   arg2 = (Dali::Degree *)jarg2;
22344   if (!arg2) {
22345     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
22346     return ;
22347   }
22348   arg3 = (Dali::Vector3 *)jarg3;
22349   if (!arg3) {
22350     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
22351     return ;
22352   }
22353   {
22354     try {
22355       (arg1)->SetProperty( Actor::Property::ORIENTATION, Quaternion( (Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3 ) );
22356     } CALL_CATCH_EXCEPTION();
22357   }
22358
22359 }
22360
22361
22362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
22363   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22364   Dali::Radian *arg2 = 0 ;
22365   Dali::Vector3 *arg3 = 0 ;
22366
22367   arg1 = (Dali::Actor *)jarg1;
22368   arg2 = (Dali::Radian *)jarg2;
22369   if (!arg2) {
22370     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
22371     return ;
22372   }
22373   arg3 = (Dali::Vector3 *)jarg3;
22374   if (!arg3) {
22375     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
22376     return ;
22377   }
22378   {
22379     try {
22380       (arg1)->SetProperty( Actor::Property::ORIENTATION, Quaternion( (Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3 ) );
22381     } CALL_CATCH_EXCEPTION();
22382   }
22383
22384 }
22385
22386
22387 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_2(void * jarg1, void * jarg2) {
22388   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22389   Dali::Quaternion *arg2 = 0 ;
22390
22391   arg1 = (Dali::Actor *)jarg1;
22392   arg2 = (Dali::Quaternion *)jarg2;
22393   if (!arg2) {
22394     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
22395     return ;
22396   }
22397   {
22398     try {
22399       (arg1)->SetProperty( Actor::Property::ORIENTATION, (Dali::Quaternion const &)*arg2 );
22400     } CALL_CATCH_EXCEPTION();
22401   }
22402
22403 }
22404
22405
22406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
22407   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22408   Dali::Degree *arg2 = 0 ;
22409   Dali::Vector3 *arg3 = 0 ;
22410
22411   arg1 = (Dali::Actor *)jarg1;
22412   arg2 = (Dali::Degree *)jarg2;
22413   if (!arg2) {
22414     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
22415     return ;
22416   }
22417   arg3 = (Dali::Vector3 *)jarg3;
22418   if (!arg3) {
22419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
22420     return ;
22421   }
22422   {
22423     try {
22424       (arg1)->RotateBy((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
22425     } CALL_CATCH_EXCEPTION();
22426   }
22427
22428 }
22429
22430
22431 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
22432   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22433   Dali::Radian *arg2 = 0 ;
22434   Dali::Vector3 *arg3 = 0 ;
22435
22436   arg1 = (Dali::Actor *)jarg1;
22437   arg2 = (Dali::Radian *)jarg2;
22438   if (!arg2) {
22439     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
22440     return ;
22441   }
22442   arg3 = (Dali::Vector3 *)jarg3;
22443   if (!arg3) {
22444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
22445     return ;
22446   }
22447   {
22448     try {
22449       (arg1)->RotateBy((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
22450     } CALL_CATCH_EXCEPTION();
22451   }
22452
22453 }
22454
22455
22456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_2(void * jarg1, void * jarg2) {
22457   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22458   Dali::Quaternion *arg2 = 0 ;
22459
22460   arg1 = (Dali::Actor *)jarg1;
22461   arg2 = (Dali::Quaternion *)jarg2;
22462   if (!arg2) {
22463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
22464     return ;
22465   }
22466   {
22467     try {
22468       (arg1)->RotateBy((Dali::Quaternion const &)*arg2);
22469     } CALL_CATCH_EXCEPTION();
22470   }
22471
22472 }
22473
22474
22475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOrientation(void * jarg1) {
22476   void * jresult ;
22477   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22478   Dali::Quaternion result;
22479
22480   arg1 = (Dali::Actor *)jarg1;
22481   {
22482     try {
22483       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION );
22484     } CALL_CATCH_EXCEPTION(0);
22485   }
22486
22487   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
22488   return jresult;
22489 }
22490
22491
22492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritOrientation(void * jarg1, unsigned int jarg2) {
22493   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22494   bool arg2 ;
22495
22496   arg1 = (Dali::Actor *)jarg1;
22497   arg2 = jarg2 ? true : false;
22498   {
22499     try {
22500       (arg1)->SetProperty( Actor::Property::INHERIT_ORIENTATION,arg2);
22501     } CALL_CATCH_EXCEPTION();
22502   }
22503
22504 }
22505
22506
22507 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsOrientationInherited(void * jarg1) {
22508   unsigned int jresult ;
22509   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22510   bool result;
22511
22512   arg1 = (Dali::Actor *)jarg1;
22513   {
22514     try {
22515       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::INHERIT_ORIENTATION );
22516     } CALL_CATCH_EXCEPTION(0);
22517   }
22518
22519   jresult = result;
22520   return jresult;
22521 }
22522
22523
22524 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldOrientation(void * jarg1) {
22525   void * jresult ;
22526   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22527   Dali::Quaternion result;
22528
22529   arg1 = (Dali::Actor *)jarg1;
22530   {
22531     try {
22532       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Quaternion >( Actor::Property::WORLD_ORIENTATION );
22533     } CALL_CATCH_EXCEPTION(0);
22534   }
22535
22536   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
22537   return jresult;
22538 }
22539
22540
22541 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_0(void * jarg1, float jarg2) {
22542   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22543   float arg2 ;
22544
22545   arg1 = (Dali::Actor *)jarg1;
22546   arg2 = (float)jarg2;
22547   {
22548     try {
22549       (arg1)->SetProperty( Actor::Property::SCALE, arg2);
22550     } CALL_CATCH_EXCEPTION();
22551   }
22552
22553 }
22554
22555
22556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
22557   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22558   float arg2 ;
22559   float arg3 ;
22560   float arg4 ;
22561
22562   arg1 = (Dali::Actor *)jarg1;
22563   arg2 = (float)jarg2;
22564   arg3 = (float)jarg3;
22565   arg4 = (float)jarg4;
22566   {
22567     try {
22568       (arg1)->SetProperty( Actor::Property::SCALE, Vector3( arg2, arg3, arg4 ) );
22569     } CALL_CATCH_EXCEPTION();
22570   }
22571
22572 }
22573
22574
22575 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_2(void * jarg1, void * jarg2) {
22576   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22577   Dali::Vector3 *arg2 = 0 ;
22578
22579   arg1 = (Dali::Actor *)jarg1;
22580   arg2 = (Dali::Vector3 *)jarg2;
22581   if (!arg2) {
22582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
22583     return ;
22584   }
22585   {
22586     try {
22587       (arg1)->SetProperty( Actor::Property::SCALE, (Dali::Vector3 const &)*arg2 );
22588     } CALL_CATCH_EXCEPTION();
22589   }
22590
22591 }
22592
22593
22594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_ScaleBy(void * jarg1, void * jarg2) {
22595   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22596   Dali::Vector3 *arg2 = 0 ;
22597
22598   arg1 = (Dali::Actor *)jarg1;
22599   arg2 = (Dali::Vector3 *)jarg2;
22600   if (!arg2) {
22601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
22602     return ;
22603   }
22604   {
22605     try {
22606       (arg1)->ScaleBy((Dali::Vector3 const &)*arg2);
22607     } CALL_CATCH_EXCEPTION();
22608   }
22609
22610 }
22611
22612
22613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentScale(void * jarg1) {
22614   void * jresult ;
22615   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22616   Dali::Vector3 result;
22617
22618   arg1 = (Dali::Actor *)jarg1;
22619   {
22620     try {
22621       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::SCALE );
22622     } CALL_CATCH_EXCEPTION(0);
22623   }
22624
22625   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
22626   return jresult;
22627 }
22628
22629
22630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldScale(void * jarg1) {
22631   void * jresult ;
22632   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22633   Dali::Vector3 result;
22634
22635   arg1 = (Dali::Actor *)jarg1;
22636   {
22637     try {
22638       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::WORLD_SCALE );
22639     } CALL_CATCH_EXCEPTION(0);
22640   }
22641
22642   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
22643   return jresult;
22644 }
22645
22646
22647 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritScale(void * jarg1, unsigned int jarg2) {
22648   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22649   bool arg2 ;
22650
22651   arg1 = (Dali::Actor *)jarg1;
22652   arg2 = jarg2 ? true : false;
22653   {
22654     try {
22655       (arg1)->SetProperty( Actor::Property::INHERIT_SCALE,arg2);
22656     } CALL_CATCH_EXCEPTION();
22657   }
22658
22659 }
22660
22661
22662 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsScaleInherited(void * jarg1) {
22663   unsigned int jresult ;
22664   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22665   bool result;
22666
22667   arg1 = (Dali::Actor *)jarg1;
22668   {
22669     try {
22670       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::INHERIT_SCALE );
22671     } CALL_CATCH_EXCEPTION(0);
22672   }
22673
22674   jresult = result;
22675   return jresult;
22676 }
22677
22678
22679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldMatrix(void * jarg1) {
22680   void * jresult ;
22681   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22682   Dali::Matrix result;
22683
22684   arg1 = (Dali::Actor *)jarg1;
22685   {
22686     try {
22687       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Matrix >( Actor::Property::WORLD_MATRIX );
22688     } CALL_CATCH_EXCEPTION(0);
22689   }
22690
22691   jresult = new Dali::Matrix((const Dali::Matrix &)result);
22692   return jresult;
22693 }
22694
22695
22696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetVisible(void * jarg1, unsigned int jarg2) {
22697   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22698   bool arg2 ;
22699
22700   arg1 = (Dali::Actor *)jarg1;
22701   arg2 = jarg2 ? true : false;
22702   {
22703     try {
22704       (arg1)->SetProperty( Actor::Property::VISIBLE,arg2);
22705     } CALL_CATCH_EXCEPTION();
22706   }
22707
22708 }
22709
22710
22711 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsVisible(void * jarg1) {
22712   unsigned int jresult ;
22713   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22714   bool result;
22715
22716   arg1 = (Dali::Actor *)jarg1;
22717   {
22718     try {
22719       result = (bool)((Dali::Actor const *)arg1)->GetCurrentProperty< bool >( Actor::Property::VISIBLE );
22720     } CALL_CATCH_EXCEPTION(0);
22721   }
22722
22723   jresult = result;
22724   return jresult;
22725 }
22726
22727
22728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOpacity(void * jarg1, float jarg2) {
22729   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22730   float arg2 ;
22731
22732   arg1 = (Dali::Actor *)jarg1;
22733   arg2 = (float)jarg2;
22734   {
22735     try {
22736       (arg1)->SetProperty( Actor::Property::OPACITY,arg2);
22737     } CALL_CATCH_EXCEPTION();
22738   }
22739
22740 }
22741
22742
22743 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOpacity(void * jarg1) {
22744   float jresult ;
22745   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22746   float result;
22747
22748   arg1 = (Dali::Actor *)jarg1;
22749   {
22750     try {
22751       result = (float)((Dali::Actor const *)arg1)->GetCurrentProperty< float >( Actor::Property::OPACITY );
22752     } CALL_CATCH_EXCEPTION(0);
22753   }
22754
22755   jresult = result;
22756   return jresult;
22757 }
22758
22759
22760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColor(void * jarg1, void * jarg2) {
22761   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22762   Dali::Vector4 *arg2 = 0 ;
22763
22764   arg1 = (Dali::Actor *)jarg1;
22765   arg2 = (Dali::Vector4 *)jarg2;
22766   if (!arg2) {
22767     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
22768     return ;
22769   }
22770   {
22771     try {
22772       (arg1)->SetProperty( Actor::Property::COLOR,(Dali::Vector4 const &)*arg2);
22773     } CALL_CATCH_EXCEPTION();
22774   }
22775
22776 }
22777
22778
22779 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentColor(void * jarg1) {
22780   void * jresult ;
22781   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22782   Dali::Vector4 result;
22783
22784   arg1 = (Dali::Actor *)jarg1;
22785   {
22786     try {
22787       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector4 >( Actor::Property::COLOR );
22788     } CALL_CATCH_EXCEPTION(0);
22789   }
22790
22791   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
22792   return jresult;
22793 }
22794
22795
22796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColorMode(void * jarg1, int jarg2) {
22797   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22798   Dali::ColorMode arg2 ;
22799
22800   arg1 = (Dali::Actor *)jarg1;
22801   arg2 = (Dali::ColorMode)jarg2;
22802   {
22803     try {
22804       (arg1)->SetProperty( Actor::Property::COLOR_MODE,arg2);
22805     } CALL_CATCH_EXCEPTION();
22806   }
22807
22808 }
22809
22810
22811 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetColorMode(void * jarg1) {
22812   int jresult ;
22813   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22814   Dali::ColorMode result;
22815
22816   arg1 = (Dali::Actor *)jarg1;
22817   {
22818     try {
22819       result = (Dali::ColorMode)((Dali::Actor const *)arg1)->GetProperty< ColorMode >( Actor::Property::COLOR_MODE );
22820     } CALL_CATCH_EXCEPTION(0);
22821   }
22822
22823   jresult = (int)result;
22824   return jresult;
22825 }
22826
22827
22828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldColor(void * jarg1) {
22829   void * jresult ;
22830   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22831   Dali::Vector4 result;
22832
22833   arg1 = (Dali::Actor *)jarg1;
22834   {
22835     try {
22836       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector4 >( Actor::Property::WORLD_COLOR );
22837     } CALL_CATCH_EXCEPTION(0);
22838   }
22839
22840   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
22841   return jresult;
22842 }
22843
22844
22845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetDrawMode(void * jarg1, int jarg2) {
22846   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22847   Dali::DrawMode::Type arg2 ;
22848
22849   arg1 = (Dali::Actor *)jarg1;
22850   arg2 = (Dali::DrawMode::Type)jarg2;
22851   {
22852     try {
22853       (arg1)->SetProperty( Actor::Property::DRAW_MODE,arg2);
22854     } CALL_CATCH_EXCEPTION();
22855   }
22856
22857 }
22858
22859
22860 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetDrawMode(void * jarg1) {
22861   int jresult ;
22862   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22863   Dali::DrawMode::Type result;
22864
22865   arg1 = (Dali::Actor *)jarg1;
22866   {
22867     try {
22868       result = (Dali::DrawMode::Type)((Dali::Actor const *)arg1)->GetProperty< DrawMode::Type >( Actor::Property::DRAW_MODE );
22869     } CALL_CATCH_EXCEPTION(0);
22870   }
22871
22872   jresult = (int)result;
22873   return jresult;
22874 }
22875
22876
22877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSensitive(void * jarg1, unsigned int jarg2) {
22878   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22879   bool arg2 ;
22880
22881   arg1 = (Dali::Actor *)jarg1;
22882   arg2 = jarg2 ? true : false;
22883   {
22884     try {
22885       (arg1)->SetProperty( Actor::Property::SENSITIVE,arg2);
22886     } CALL_CATCH_EXCEPTION();
22887   }
22888
22889 }
22890
22891
22892 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsSensitive(void * jarg1) {
22893   unsigned int jresult ;
22894   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22895   bool result;
22896
22897   arg1 = (Dali::Actor *)jarg1;
22898   {
22899     try {
22900       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::SENSITIVE );
22901     } CALL_CATCH_EXCEPTION(0);
22902   }
22903
22904   jresult = result;
22905   return jresult;
22906 }
22907
22908
22909 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_ScreenToLocal(void * jarg1, float * jarg2, float * jarg3, float jarg4, float jarg5) {
22910   unsigned int jresult ;
22911   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22912   float *arg2 = 0 ;
22913   float *arg3 = 0 ;
22914   float arg4 ;
22915   float arg5 ;
22916   bool result;
22917
22918   arg1 = (Dali::Actor *)jarg1;
22919   arg2 = (float *)jarg2;
22920   arg3 = (float *)jarg3;
22921   arg4 = (float)jarg4;
22922   arg5 = (float)jarg5;
22923   {
22924     try {
22925       result = (bool)((Dali::Actor const *)arg1)->ScreenToLocal(*arg2,*arg3,arg4,arg5);
22926     } CALL_CATCH_EXCEPTION(0);
22927   }
22928
22929   jresult = result;
22930   return jresult;
22931 }
22932
22933
22934 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetLeaveRequired(void * jarg1, unsigned int jarg2) {
22935   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22936   bool arg2 ;
22937
22938   arg1 = (Dali::Actor *)jarg1;
22939   arg2 = jarg2 ? true : false;
22940   {
22941     try {
22942       (arg1)->SetProperty( Actor::Property::LEAVE_REQUIRED,arg2);
22943     } CALL_CATCH_EXCEPTION();
22944   }
22945
22946 }
22947
22948
22949 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetLeaveRequired(void * jarg1) {
22950   unsigned int jresult ;
22951   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22952   bool result;
22953
22954   arg1 = (Dali::Actor *)jarg1;
22955   {
22956     try {
22957       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::LEAVE_REQUIRED );
22958     } CALL_CATCH_EXCEPTION(0);
22959   }
22960
22961   jresult = result;
22962   return jresult;
22963 }
22964
22965
22966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusable(void * jarg1, unsigned int jarg2) {
22967   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22968   bool arg2 ;
22969
22970   arg1 = (Dali::Actor *)jarg1;
22971   arg2 = jarg2 ? true : false;
22972   {
22973     try {
22974       (arg1)->SetProperty( Actor::Property::KEYBOARD_FOCUSABLE, arg2 );
22975     } CALL_CATCH_EXCEPTION();
22976   }
22977
22978 }
22979
22980
22981 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsKeyboardFocusable(void * jarg1) {
22982   unsigned int jresult ;
22983   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22984   bool result;
22985
22986   arg1 = (Dali::Actor *)jarg1;
22987   {
22988     try {
22989       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::KEYBOARD_FOCUSABLE );
22990     } CALL_CATCH_EXCEPTION(0);
22991   }
22992
22993   jresult = result;
22994   return jresult;
22995 }
22996
22997
22998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetResizePolicy(void * jarg1, int jarg2, int jarg3) {
22999   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23000   Dali::ResizePolicy::Type arg2 ;
23001   Dali::Dimension::Type arg3 ;
23002
23003   arg1 = (Dali::Actor *)jarg1;
23004   arg2 = (Dali::ResizePolicy::Type)jarg2;
23005   arg3 = (Dali::Dimension::Type)jarg3;
23006   {
23007     try {
23008       (arg1)->SetResizePolicy(arg2,arg3);
23009     } CALL_CATCH_EXCEPTION();
23010   }
23011
23012 }
23013
23014
23015 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetResizePolicy(void * jarg1, int jarg2) {
23016   int jresult ;
23017   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23018   Dali::Dimension::Type arg2 ;
23019   Dali::ResizePolicy::Type result;
23020
23021   arg1 = (Dali::Actor *)jarg1;
23022   arg2 = (Dali::Dimension::Type)jarg2;
23023   {
23024     try {
23025       result = (Dali::ResizePolicy::Type)((Dali::Actor const *)arg1)->GetResizePolicy(arg2);
23026     } CALL_CATCH_EXCEPTION(0);
23027   }
23028
23029   jresult = (int)result;
23030   return jresult;
23031 }
23032
23033
23034 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeScalePolicy(void * jarg1, int jarg2) {
23035   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23036   Dali::SizeScalePolicy::Type arg2 ;
23037
23038   arg1 = (Dali::Actor *)jarg1;
23039   arg2 = (Dali::SizeScalePolicy::Type)jarg2;
23040   {
23041     try {
23042       (arg1)->SetProperty( Actor::Property::SIZE_SCALE_POLICY,arg2);
23043     } CALL_CATCH_EXCEPTION();
23044   }
23045
23046 }
23047
23048
23049 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetSizeScalePolicy(void * jarg1) {
23050   int jresult ;
23051   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23052   Dali::SizeScalePolicy::Type result;
23053
23054   arg1 = (Dali::Actor *)jarg1;
23055   {
23056     try {
23057       result = (Dali::SizeScalePolicy::Type)((Dali::Actor const *)arg1)->GetProperty< SizeScalePolicy::Type >( Actor::Property::SIZE_SCALE_POLICY );
23058     } CALL_CATCH_EXCEPTION(0);
23059   }
23060
23061   jresult = (int)result;
23062   return jresult;
23063 }
23064
23065
23066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeModeFactor(void * jarg1, void * jarg2) {
23067   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23068   Dali::Vector3 *arg2 = 0 ;
23069
23070   arg1 = (Dali::Actor *)jarg1;
23071   arg2 = (Dali::Vector3 *)jarg2;
23072   if (!arg2) {
23073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
23074     return ;
23075   }
23076   {
23077     try {
23078       (arg1)->SetProperty( Actor::Property::SIZE_MODE_FACTOR, (Dali::Vector3 const &)*arg2);
23079     } CALL_CATCH_EXCEPTION();
23080   }
23081
23082 }
23083
23084
23085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetSizeModeFactor(void * jarg1) {
23086   void * jresult ;
23087   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23088   Dali::Vector3 result;
23089
23090   arg1 = (Dali::Actor *)jarg1;
23091   {
23092     try {
23093       result = ((Dali::Actor const *)arg1)->GetProperty< Vector3 >( Actor::Property::SIZE_MODE_FACTOR );
23094     } CALL_CATCH_EXCEPTION(0);
23095   }
23096
23097   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
23098   return jresult;
23099 }
23100
23101
23102 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetHeightForWidth(void * jarg1, float jarg2) {
23103   float jresult ;
23104   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23105   float arg2 ;
23106   float result;
23107
23108   arg1 = (Dali::Actor *)jarg1;
23109   arg2 = (float)jarg2;
23110   {
23111     try {
23112       result = (float)(arg1)->GetHeightForWidth(arg2);
23113     } CALL_CATCH_EXCEPTION(0);
23114   }
23115
23116   jresult = result;
23117   return jresult;
23118 }
23119
23120
23121 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetWidthForHeight(void * jarg1, float jarg2) {
23122   float jresult ;
23123   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23124   float arg2 ;
23125   float result;
23126
23127   arg1 = (Dali::Actor *)jarg1;
23128   arg2 = (float)jarg2;
23129   {
23130     try {
23131       result = (float)(arg1)->GetWidthForHeight(arg2);
23132     } CALL_CATCH_EXCEPTION(0);
23133   }
23134
23135   jresult = result;
23136   return jresult;
23137 }
23138
23139
23140 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetRelayoutSize(void * jarg1, int jarg2) {
23141   float jresult ;
23142   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23143   Dali::Dimension::Type arg2 ;
23144   float result;
23145
23146   arg1 = (Dali::Actor *)jarg1;
23147   arg2 = (Dali::Dimension::Type)jarg2;
23148   {
23149     try {
23150       result = (float)((Dali::Actor const *)arg1)->GetRelayoutSize(arg2);
23151     } CALL_CATCH_EXCEPTION(0);
23152   }
23153
23154   jresult = result;
23155   return jresult;
23156 }
23157
23158
23159 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPadding(void * jarg1, void * jarg2) {
23160   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23161   Dali::Padding *arg2 = 0 ;
23162
23163   arg1 = (Dali::Actor *)jarg1;
23164   arg2 = (Dali::Padding *)jarg2;
23165   if (!arg2) {
23166     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding const & type is null", 0);
23167     return ;
23168   }
23169   {
23170     try {
23171       (arg1)->SetProperty( Actor::Property::PADDING, (Dali::Padding const &)*arg2);
23172     } CALL_CATCH_EXCEPTION();
23173   }
23174
23175 }
23176
23177
23178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_GetPadding(void * jarg1, void * jarg2) {
23179   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23180   Dali::Padding *arg2 = 0 ;
23181
23182   arg1 = (Dali::Actor *)jarg1;
23183   arg2 = (Dali::Padding *)jarg2;
23184   if (!arg2) {
23185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding & type is null", 0);
23186     return ;
23187   }
23188   {
23189     try {
23190       *arg2 = ((Dali::Actor const *)arg1)->GetProperty<Vector4>( Actor::Property::PADDING );
23191     } CALL_CATCH_EXCEPTION();
23192   }
23193
23194 }
23195
23196
23197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMinimumSize(void * jarg1, void * jarg2) {
23198   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23199   Dali::Vector2 *arg2 = 0 ;
23200
23201   arg1 = (Dali::Actor *)jarg1;
23202   arg2 = (Dali::Vector2 *)jarg2;
23203   if (!arg2) {
23204     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
23205     return ;
23206   }
23207   {
23208     try {
23209       (arg1)->SetProperty( Actor::Property::MINIMUM_SIZE,(Dali::Vector2 const &)*arg2);
23210     } CALL_CATCH_EXCEPTION();
23211   }
23212
23213 }
23214
23215
23216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMinimumSize(void * jarg1) {
23217   void * jresult ;
23218   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23219   Dali::Vector2 result;
23220
23221   arg1 = (Dali::Actor *)jarg1;
23222   {
23223     try {
23224       result = (arg1)->GetProperty< Vector2 >( Actor::Property::MINIMUM_SIZE );
23225     } CALL_CATCH_EXCEPTION(0);
23226   }
23227
23228   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
23229   return jresult;
23230 }
23231
23232
23233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMaximumSize(void * jarg1, void * jarg2) {
23234   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23235   Dali::Vector2 *arg2 = 0 ;
23236
23237   arg1 = (Dali::Actor *)jarg1;
23238   arg2 = (Dali::Vector2 *)jarg2;
23239   if (!arg2) {
23240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
23241     return ;
23242   }
23243   {
23244     try {
23245       (arg1)->SetProperty( Actor::Property::MAXIMUM_SIZE,(Dali::Vector2 const &)*arg2);
23246     } CALL_CATCH_EXCEPTION();
23247   }
23248
23249 }
23250
23251
23252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMaximumSize(void * jarg1) {
23253   void * jresult ;
23254   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23255   Dali::Vector2 result;
23256
23257   arg1 = (Dali::Actor *)jarg1;
23258   {
23259     try {
23260       result = (arg1)->GetProperty< Vector2 >( Actor::Property::MAXIMUM_SIZE );
23261     } CALL_CATCH_EXCEPTION(0);
23262   }
23263
23264   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
23265   return jresult;
23266 }
23267
23268
23269 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetHierarchyDepth(void * jarg1) {
23270   int jresult ;
23271   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23272   int result;
23273
23274   arg1 = (Dali::Actor *)jarg1;
23275   {
23276     try {
23277       result = (int)(arg1)->GetProperty< int >( Actor::Property::HIERARCHY_DEPTH );
23278       Dali::Actor parent = ((Dali::Actor const *)arg1)->GetParent();
23279     } CALL_CATCH_EXCEPTION(0);
23280   }
23281
23282   jresult = result;
23283   return jresult;
23284 }
23285
23286
23287 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_AddRenderer(void * jarg1, void * jarg2) {
23288   unsigned int jresult ;
23289   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23290   Dali::Renderer *arg2 = 0 ;
23291   unsigned int result;
23292
23293   arg1 = (Dali::Actor *)jarg1;
23294   arg2 = (Dali::Renderer *)jarg2;
23295   if (!arg2) {
23296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
23297     return 0;
23298   }
23299   {
23300     try {
23301       result = (unsigned int)(arg1)->AddRenderer(*arg2);
23302     } CALL_CATCH_EXCEPTION(0);
23303   }
23304
23305   jresult = result;
23306   return jresult;
23307 }
23308
23309
23310 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetRendererCount(void * jarg1) {
23311   unsigned int jresult ;
23312   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23313   unsigned int result;
23314
23315   arg1 = (Dali::Actor *)jarg1;
23316   {
23317     try {
23318       result = (unsigned int)((Dali::Actor const *)arg1)->GetRendererCount();
23319     } CALL_CATCH_EXCEPTION(0);
23320   }
23321
23322   jresult = result;
23323   return jresult;
23324 }
23325
23326
23327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetRendererAt(void * jarg1, unsigned int jarg2) {
23328   void * jresult ;
23329   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23330   unsigned int arg2 ;
23331   Dali::Renderer result;
23332
23333   arg1 = (Dali::Actor *)jarg1;
23334   arg2 = (unsigned int)jarg2;
23335   {
23336     try {
23337       result = (arg1)->GetRendererAt(arg2);
23338     } CALL_CATCH_EXCEPTION(0);
23339   }
23340
23341   jresult = new Dali::Renderer((const Dali::Renderer &)result);
23342   return jresult;
23343 }
23344
23345
23346 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_0(void * jarg1, void * jarg2) {
23347   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23348   Dali::Renderer *arg2 = 0 ;
23349
23350   arg1 = (Dali::Actor *)jarg1;
23351   arg2 = (Dali::Renderer *)jarg2;
23352   if (!arg2) {
23353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
23354     return ;
23355   }
23356   {
23357     try {
23358       (arg1)->RemoveRenderer(*arg2);
23359     } CALL_CATCH_EXCEPTION();
23360   }
23361
23362 }
23363
23364
23365 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_1(void * jarg1, unsigned int jarg2) {
23366   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23367   unsigned int arg2 ;
23368
23369   arg1 = (Dali::Actor *)jarg1;
23370   arg2 = (unsigned int)jarg2;
23371   {
23372     try {
23373       (arg1)->RemoveRenderer(arg2);
23374     } CALL_CATCH_EXCEPTION();
23375   }
23376
23377 }
23378
23379
23380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchSignal(void * jarg1) {
23381   void * jresult ;
23382   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23383   Dali::Actor::TouchEventSignalType *result = 0 ;
23384
23385   arg1 = (Dali::Actor *)jarg1;
23386   {
23387     try {
23388       result = (Dali::Actor::TouchEventSignalType *) &(arg1)->TouchSignal();
23389     } CALL_CATCH_EXCEPTION(0);
23390   }
23391
23392   jresult = (void *)result;
23393   return jresult;
23394 }
23395
23396
23397 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_HoveredSignal(void * jarg1) {
23398   void * jresult ;
23399   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23400   Dali::Actor::HoverSignalType *result = 0 ;
23401
23402   arg1 = (Dali::Actor *)jarg1;
23403   {
23404     try {
23405       result = (Dali::Actor::HoverSignalType *) &(arg1)->HoveredSignal();
23406     } CALL_CATCH_EXCEPTION(0);
23407   }
23408
23409   jresult = (void *)result;
23410   return jresult;
23411 }
23412
23413
23414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_WheelEventSignal(void * jarg1) {
23415   void * jresult ;
23416   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23417   Dali::Actor::WheelEventSignalType *result = 0 ;
23418
23419   arg1 = (Dali::Actor *)jarg1;
23420   {
23421     try {
23422       result = (Dali::Actor::WheelEventSignalType *) &(arg1)->WheelEventSignal();
23423     } CALL_CATCH_EXCEPTION(0);
23424   }
23425
23426   jresult = (void *)result;
23427   return jresult;
23428 }
23429
23430
23431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnSceneSignal(void * jarg1) {
23432   void * jresult ;
23433   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23434   Dali::Actor::OnSceneSignalType *result = 0 ;
23435
23436   arg1 = (Dali::Actor *)jarg1;
23437   {
23438     try {
23439       result = (Dali::Actor::OnSceneSignalType *) &(arg1)->OnSceneSignal();
23440     } CALL_CATCH_EXCEPTION(0);
23441   }
23442
23443   jresult = (void *)result;
23444   return jresult;
23445 }
23446
23447
23448 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OffSceneSignal(void * jarg1) {
23449   void * jresult ;
23450   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23451   Dali::Actor::OffSceneSignalType *result = 0 ;
23452
23453   arg1 = (Dali::Actor *)jarg1;
23454   {
23455     try {
23456       result = (Dali::Actor::OffSceneSignalType *) &(arg1)->OffSceneSignal();
23457     } CALL_CATCH_EXCEPTION(0);
23458   }
23459
23460   jresult = (void *)result;
23461   return jresult;
23462 }
23463
23464
23465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnRelayoutSignal(void * jarg1) {
23466   void * jresult ;
23467   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23468   Dali::Actor::OnRelayoutSignalType *result = 0 ;
23469
23470   arg1 = (Dali::Actor *)jarg1;
23471   {
23472     try {
23473       result = (Dali::Actor::OnRelayoutSignalType *) &(arg1)->OnRelayoutSignal();
23474     } CALL_CATCH_EXCEPTION(0);
23475   }
23476
23477   jresult = (void *)result;
23478   return jresult;
23479 }
23480
23481
23482 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_UnparentAndReset(void * jarg1) {
23483   Dali::Actor *arg1 = 0 ;
23484
23485   arg1 = (Dali::Actor *)jarg1;
23486   if (!arg1) {
23487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
23488     return ;
23489   }
23490   {
23491     try {
23492       Dali::UnparentAndReset(*arg1);
23493     } CALL_CATCH_EXCEPTION();
23494   }
23495
23496 }
23497
23498
23499 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_ENABLE_get() {
23500   int jresult ;
23501   int result;
23502
23503   result = (int)Dali::Layer::Property::CLIPPING_ENABLE;
23504   jresult = (int)result;
23505   return jresult;
23506 }
23507
23508
23509 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_BOX_get() {
23510   int jresult ;
23511   int result;
23512
23513   result = (int)Dali::Layer::Property::CLIPPING_BOX;
23514   jresult = (int)result;
23515   return jresult;
23516 }
23517
23518
23519 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_BEHAVIOR_get() {
23520   int jresult ;
23521   int result;
23522
23523   result = (int)Dali::Layer::Property::BEHAVIOR;
23524   jresult = (int)result;
23525   return jresult;
23526 }
23527
23528
23529 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer_Property() {
23530   void * jresult ;
23531   Dali::Layer::Property *result = 0 ;
23532
23533   {
23534     try {
23535       result = (Dali::Layer::Property *)new Dali::Layer::Property();
23536     } CALL_CATCH_EXCEPTION(0);
23537   }
23538
23539   jresult = (void *)result;
23540   return jresult;
23541 }
23542
23543
23544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer_Property(void * jarg1) {
23545   Dali::Layer::Property *arg1 = (Dali::Layer::Property *) 0 ;
23546
23547   arg1 = (Dali::Layer::Property *)jarg1;
23548   {
23549     try {
23550       delete arg1;
23551     } CALL_CATCH_EXCEPTION();
23552   }
23553
23554 }
23555
23556
23557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_0() {
23558   void * jresult ;
23559   Dali::Layer *result = 0 ;
23560
23561   {
23562     try {
23563       result = (Dali::Layer *)new Dali::Layer();
23564     } CALL_CATCH_EXCEPTION(0);
23565   }
23566
23567   jresult = (void *)result;
23568   return jresult;
23569 }
23570
23571
23572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_New() {
23573   void * jresult ;
23574   Dali::Layer result;
23575
23576   {
23577     try {
23578       result = Dali::Layer::New();
23579     } CALL_CATCH_EXCEPTION(0);
23580   }
23581
23582   jresult = new Dali::Layer((const Dali::Layer &)result);
23583   return jresult;
23584 }
23585
23586
23587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_DownCast(void * jarg1) {
23588   void * jresult ;
23589   Dali::BaseHandle arg1 ;
23590   Dali::BaseHandle *argp1 ;
23591   Dali::Layer result;
23592
23593   argp1 = (Dali::BaseHandle *)jarg1;
23594   if (!argp1) {
23595     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
23596     return 0;
23597   }
23598   arg1 = *argp1;
23599   {
23600     try {
23601       result = Dali::Layer::DownCast(arg1);
23602     } CALL_CATCH_EXCEPTION(0);
23603   }
23604
23605   jresult = new Dali::Layer((const Dali::Layer &)result);
23606   return jresult;
23607 }
23608
23609
23610 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer(void * jarg1) {
23611   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23612
23613   arg1 = (Dali::Layer *)jarg1;
23614   {
23615     try {
23616       delete arg1;
23617     } CALL_CATCH_EXCEPTION();
23618   }
23619
23620 }
23621
23622
23623 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_1(void * jarg1) {
23624   void * jresult ;
23625   Dali::Layer *arg1 = 0 ;
23626   Dali::Layer *result = 0 ;
23627
23628   arg1 = (Dali::Layer *)jarg1;
23629   if (!arg1) {
23630     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
23631     return 0;
23632   }
23633   {
23634     try {
23635       result = (Dali::Layer *)new Dali::Layer((Dali::Layer const &)*arg1);
23636     } CALL_CATCH_EXCEPTION(0);
23637   }
23638
23639   jresult = (void *)result;
23640   return jresult;
23641 }
23642
23643
23644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_Assign(void * jarg1, void * jarg2) {
23645   void * jresult ;
23646   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23647   Dali::Layer *arg2 = 0 ;
23648   Dali::Layer *result = 0 ;
23649
23650   arg1 = (Dali::Layer *)jarg1;
23651   arg2 = (Dali::Layer *)jarg2;
23652   if (!arg2) {
23653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
23654     return 0;
23655   }
23656   {
23657     try {
23658       result = (Dali::Layer *) &(arg1)->operator =((Dali::Layer const &)*arg2);
23659     } CALL_CATCH_EXCEPTION(0);
23660   }
23661
23662   jresult = (void *)result;
23663   return jresult;
23664 }
23665
23666
23667 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_GetDepth(void * jarg1) {
23668   unsigned int jresult ;
23669   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23670   unsigned int result;
23671
23672   arg1 = (Dali::Layer *)jarg1;
23673   {
23674     try {
23675       result = (unsigned int)((Dali::Layer const *)arg1)->GetProperty< int >( Layer::Property::DEPTH );
23676     } CALL_CATCH_EXCEPTION(0);
23677   }
23678
23679   jresult = result;
23680   return jresult;
23681 }
23682
23683
23684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Raise(void * jarg1) {
23685   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23686
23687   arg1 = (Dali::Layer *)jarg1;
23688   {
23689     try {
23690       (arg1)->Raise();
23691     } CALL_CATCH_EXCEPTION();
23692   }
23693
23694 }
23695
23696
23697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Lower(void * jarg1) {
23698   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23699
23700   arg1 = (Dali::Layer *)jarg1;
23701   {
23702     try {
23703       (arg1)->Lower();
23704     } CALL_CATCH_EXCEPTION();
23705   }
23706
23707 }
23708
23709
23710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseAbove(void * jarg1, void * jarg2) {
23711   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23712   Dali::Layer arg2 ;
23713   Dali::Layer *argp2 ;
23714
23715   arg1 = (Dali::Layer *)jarg1;
23716   argp2 = (Dali::Layer *)jarg2;
23717   if (!argp2) {
23718     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
23719     return ;
23720   }
23721   arg2 = *argp2;
23722   {
23723     try {
23724       (arg1)->RaiseAbove(arg2);
23725     } CALL_CATCH_EXCEPTION();
23726   }
23727
23728 }
23729
23730
23731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerBelow(void * jarg1, void * jarg2) {
23732   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23733   Dali::Layer arg2 ;
23734   Dali::Layer *argp2 ;
23735
23736   arg1 = (Dali::Layer *)jarg1;
23737   argp2 = (Dali::Layer *)jarg2;
23738   if (!argp2) {
23739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
23740     return ;
23741   }
23742   arg2 = *argp2;
23743   {
23744     try {
23745       (arg1)->LowerBelow(arg2);
23746     } CALL_CATCH_EXCEPTION();
23747   }
23748
23749 }
23750
23751
23752 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseToTop(void * jarg1) {
23753   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23754
23755   arg1 = (Dali::Layer *)jarg1;
23756   {
23757     try {
23758       (arg1)->RaiseToTop();
23759     } CALL_CATCH_EXCEPTION();
23760   }
23761
23762 }
23763
23764
23765 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerToBottom(void * jarg1) {
23766   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23767
23768   arg1 = (Dali::Layer *)jarg1;
23769   {
23770     try {
23771       (arg1)->LowerToBottom();
23772     } CALL_CATCH_EXCEPTION();
23773   }
23774
23775 }
23776
23777
23778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveAbove(void * jarg1, void * jarg2) {
23779   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23780   Dali::Layer arg2 ;
23781   Dali::Layer *argp2 ;
23782
23783   arg1 = (Dali::Layer *)jarg1;
23784   argp2 = (Dali::Layer *)jarg2;
23785   if (!argp2) {
23786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
23787     return ;
23788   }
23789   arg2 = *argp2;
23790   {
23791     try {
23792       (arg1)->MoveAbove(arg2);
23793     } CALL_CATCH_EXCEPTION();
23794   }
23795
23796 }
23797
23798
23799 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveBelow(void * jarg1, void * jarg2) {
23800   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23801   Dali::Layer arg2 ;
23802   Dali::Layer *argp2 ;
23803
23804   arg1 = (Dali::Layer *)jarg1;
23805   argp2 = (Dali::Layer *)jarg2;
23806   if (!argp2) {
23807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
23808     return ;
23809   }
23810   arg2 = *argp2;
23811   {
23812     try {
23813       (arg1)->MoveBelow(arg2);
23814     } CALL_CATCH_EXCEPTION();
23815   }
23816
23817 }
23818
23819
23820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetBehavior(void * jarg1, int jarg2) {
23821   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23822   Dali::Layer::Behavior arg2 ;
23823
23824   arg1 = (Dali::Layer *)jarg1;
23825   arg2 = (Dali::Layer::Behavior)jarg2;
23826   {
23827     try {
23828       (arg1)->SetProperty( Layer::Property::BEHAVIOR, arg2 );
23829     } CALL_CATCH_EXCEPTION();
23830   }
23831
23832 }
23833
23834
23835 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_GetBehavior(void * jarg1) {
23836   int jresult ;
23837   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23838   Dali::Layer::Behavior result;
23839
23840   arg1 = (Dali::Layer *)jarg1;
23841   {
23842     try {
23843       result = (Dali::Layer::Behavior)((Dali::Layer const *)arg1)->GetProperty<Dali::Layer::Behavior>( Dali::Layer::Property::BEHAVIOR );
23844     } CALL_CATCH_EXCEPTION(0);
23845   }
23846
23847   jresult = (int)result;
23848   return jresult;
23849 }
23850
23851
23852 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClipping(void * jarg1, unsigned int jarg2) {
23853   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23854   bool arg2 ;
23855
23856   arg1 = (Dali::Layer *)jarg1;
23857   arg2 = jarg2 ? true : false;
23858   {
23859     try {
23860       (arg1)->SetProperty( Dali::Layer::Property::CLIPPING_ENABLE, arg2 );
23861     } CALL_CATCH_EXCEPTION();
23862   }
23863
23864 }
23865
23866
23867 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsClipping(void * jarg1) {
23868   unsigned int jresult ;
23869   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23870   bool result;
23871
23872   arg1 = (Dali::Layer *)jarg1;
23873   {
23874     try {
23875       result = (bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Dali::Layer::Property::CLIPPING_ENABLE );
23876     } CALL_CATCH_EXCEPTION(0);
23877   }
23878
23879   jresult = result;
23880   return jresult;
23881 }
23882
23883
23884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_0(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
23885   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23886   int arg2 ;
23887   int arg3 ;
23888   int arg4 ;
23889   int arg5 ;
23890
23891   arg1 = (Dali::Layer *)jarg1;
23892   arg2 = (int)jarg2;
23893   arg3 = (int)jarg3;
23894   arg4 = (int)jarg4;
23895   arg5 = (int)jarg5;
23896   {
23897     try {
23898       (arg1)->SetProperty( Dali::Layer::Property::CLIPPING_BOX, Rect<int32_t>( arg2,arg3,arg4,arg5 ) );
23899     } CALL_CATCH_EXCEPTION();
23900   }
23901
23902 }
23903
23904
23905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_1(void * jarg1, void * jarg2) {
23906   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23907   Dali::ClippingBox arg2 ;
23908   Dali::ClippingBox *argp2 ;
23909
23910   arg1 = (Dali::Layer *)jarg1;
23911   argp2 = (Dali::ClippingBox *)jarg2;
23912   if (!argp2) {
23913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ClippingBox", 0);
23914     return ;
23915   }
23916   arg2 = *argp2;
23917   {
23918     try {
23919       (arg1)->SetProperty( Dali::Layer::Property::CLIPPING_BOX, arg2 );
23920     } CALL_CATCH_EXCEPTION();
23921   }
23922
23923 }
23924
23925
23926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_GetClippingBox(void * jarg1) {
23927   void * jresult ;
23928   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23929   Dali::ClippingBox result;
23930
23931   arg1 = (Dali::Layer *)jarg1;
23932   {
23933     try {
23934       result = ((Dali::Layer const *)arg1)->GetProperty< Rect<int32_t> >( Layer::Property::CLIPPING_BOX );
23935     } CALL_CATCH_EXCEPTION(0);
23936   }
23937
23938   jresult = new Dali::ClippingBox((const Dali::ClippingBox &)result);
23939   return jresult;
23940 }
23941
23942
23943 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetDepthTestDisabled(void * jarg1, unsigned int jarg2) {
23944   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23945   bool arg2 ;
23946
23947   arg1 = (Dali::Layer *)jarg1;
23948   arg2 = jarg2 ? true : false;
23949   {
23950     try {
23951       (arg1)->SetProperty( Layer::Property::DEPTH_TEST, !arg2 );
23952     } CALL_CATCH_EXCEPTION();
23953   }
23954
23955 }
23956
23957
23958 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsDepthTestDisabled(void * jarg1) {
23959   unsigned int jresult ;
23960   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23961   bool result;
23962
23963   arg1 = (Dali::Layer *)jarg1;
23964   {
23965     try {
23966       result = !(bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Layer::Property::DEPTH_TEST );
23967     } CALL_CATCH_EXCEPTION(0);
23968   }
23969
23970   jresult = result;
23971   return jresult;
23972 }
23973
23974
23975 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetSortFunction(void * jarg1, void * jarg2) {
23976   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23977   Dali::Layer::SortFunctionType arg2 = (Dali::Layer::SortFunctionType) 0 ;
23978
23979   arg1 = (Dali::Layer *)jarg1;
23980   arg2 = (Dali::Layer::SortFunctionType)jarg2;
23981   {
23982     try {
23983       (arg1)->SetSortFunction(arg2);
23984     } CALL_CATCH_EXCEPTION();
23985   }
23986
23987 }
23988
23989
23990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetTouchConsumed(void * jarg1, unsigned int jarg2) {
23991   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23992   bool arg2 ;
23993
23994   arg1 = (Dali::Layer *)jarg1;
23995   arg2 = jarg2 ? true : false;
23996   {
23997     try {
23998       (arg1)->SetProperty( Layer::Property::CONSUMES_TOUCH, arg2 );
23999     } CALL_CATCH_EXCEPTION();
24000   }
24001
24002 }
24003
24004
24005 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsTouchConsumed(void * jarg1) {
24006   unsigned int jresult ;
24007   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
24008   bool result;
24009
24010   arg1 = (Dali::Layer *)jarg1;
24011   {
24012     try {
24013       result = (bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Layer::Property::CONSUMES_TOUCH );
24014     } CALL_CATCH_EXCEPTION(0);
24015   }
24016
24017   jresult = result;
24018   return jresult;
24019 }
24020
24021
24022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetHoverConsumed(void * jarg1, unsigned int jarg2) {
24023   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
24024   bool arg2 ;
24025
24026   arg1 = (Dali::Layer *)jarg1;
24027   arg2 = jarg2 ? true : false;
24028   {
24029     try {
24030       (arg1)->SetProperty( Layer::Property::CONSUMES_HOVER, arg2 );
24031     } CALL_CATCH_EXCEPTION();
24032   }
24033
24034 }
24035
24036
24037 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsHoverConsumed(void * jarg1) {
24038   unsigned int jresult ;
24039   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
24040   bool result;
24041
24042   arg1 = (Dali::Layer *)jarg1;
24043   {
24044     try {
24045       result = (bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Layer::Property::CONSUMES_HOVER );
24046     } CALL_CATCH_EXCEPTION(0);
24047   }
24048
24049   jresult = result;
24050   return jresult;
24051 }
24052
24053
24054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetCurrent() {
24055   void * jresult ;
24056   Dali::Stage result;
24057
24058   {
24059     try {
24060       result = Dali::Stage::GetCurrent();
24061     } CALL_CATCH_EXCEPTION(0);
24062   }
24063
24064   jresult = new Dali::Stage((const Dali::Stage &)result);
24065   return jresult;
24066 }
24067
24068
24069 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_IsInstalled() {
24070   unsigned int jresult ;
24071   bool result;
24072
24073   {
24074     try {
24075       result = (bool)Dali::Stage::IsInstalled();
24076     } CALL_CATCH_EXCEPTION(0);
24077   }
24078
24079   jresult = result;
24080   return jresult;
24081 }
24082
24083
24084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetDpi(void * jarg1) {
24085   void * jresult ;
24086   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
24087   Dali::Vector2 result;
24088
24089   arg1 = (Dali::Stage *)jarg1;
24090   {
24091     try {
24092       result = ((Dali::Stage const *)arg1)->GetDpi();
24093     } CALL_CATCH_EXCEPTION(0);
24094   }
24095
24096   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
24097   return jresult;
24098 }
24099
24100
24101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_KeepRendering(void * jarg1, float jarg2) {
24102   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
24103   float arg2 ;
24104
24105   arg1 = (Dali::Stage *)jarg1;
24106   arg2 = (float)jarg2;
24107   {
24108     try {
24109       (arg1)->KeepRendering(arg2);
24110     } CALL_CATCH_EXCEPTION();
24111   }
24112
24113 }
24114
24115
24116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_KeyEventSignal(void * jarg1) {
24117   void * jresult ;
24118   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
24119   Dali::Stage::KeyEventSignalType *result = 0 ;
24120
24121   arg1 = (Dali::Stage *)jarg1;
24122   {
24123     try {
24124       result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal();
24125     } CALL_CATCH_EXCEPTION(0);
24126   }
24127
24128   jresult = (void *)result;
24129   return jresult;
24130 }
24131
24132
24133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_EventProcessingFinishedSignal(void * jarg1) {
24134   void * jresult ;
24135   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
24136   Dali::Stage::EventProcessingFinishedSignalType *result = 0 ;
24137
24138   arg1 = (Dali::Stage *)jarg1;
24139   {
24140     try {
24141       result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal();
24142     } CALL_CATCH_EXCEPTION(0);
24143   }
24144
24145   jresult = (void *)result;
24146   return jresult;
24147 }
24148
24149
24150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_TouchSignal(void * jarg1) {
24151   void * jresult ;
24152   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
24153   Dali::Stage::TouchSignalType *result = 0 ;
24154
24155   arg1 = (Dali::Stage *)jarg1;
24156   {
24157     try {
24158       result = (Dali::Stage::TouchSignalType *) &(arg1)->TouchSignal();
24159     } CALL_CATCH_EXCEPTION(0);
24160   }
24161
24162   jresult = (void *)result;
24163   return jresult;
24164 }
24165
24166
24167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_WheelEventSignal(void * jarg1) {
24168   void * jresult ;
24169   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
24170   Dali::Stage::WheelEventSignalType *result = 0 ;
24171
24172   arg1 = (Dali::Stage *)jarg1;
24173   {
24174     try {
24175       result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal();
24176     } CALL_CATCH_EXCEPTION(0);
24177   }
24178
24179   jresult = (void *)result;
24180   return jresult;
24181 }
24182
24183
24184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextLostSignal(void * jarg1) {
24185   void * jresult ;
24186   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
24187   Dali::Stage::ContextStatusSignal *result = 0 ;
24188
24189   arg1 = (Dali::Stage *)jarg1;
24190   {
24191     try {
24192       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal();
24193     } CALL_CATCH_EXCEPTION(0);
24194   }
24195
24196   jresult = (void *)result;
24197   return jresult;
24198 }
24199
24200
24201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextRegainedSignal(void * jarg1) {
24202   void * jresult ;
24203   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
24204   Dali::Stage::ContextStatusSignal *result = 0 ;
24205
24206   arg1 = (Dali::Stage *)jarg1;
24207   {
24208     try {
24209       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextRegainedSignal();
24210     } CALL_CATCH_EXCEPTION(0);
24211   }
24212
24213   jresult = (void *)result;
24214   return jresult;
24215 }
24216
24217
24218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_SceneCreatedSignal(void * jarg1) {
24219   void * jresult ;
24220   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
24221   Dali::Stage::SceneCreatedSignalType *result = 0 ;
24222
24223   arg1 = (Dali::Stage *)jarg1;
24224   {
24225     try {
24226       result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal();
24227     } CALL_CATCH_EXCEPTION(0);
24228   }
24229
24230   jresult = (void *)result;
24231   return jresult;
24232 }
24233
24234 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetRenderingBehavior(void * jarg1, int jarg2) {
24235   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
24236   Dali::DevelStage::Rendering arg2 ;
24237
24238   arg1 = (Dali::Stage *)jarg1;
24239   arg2 = (Dali::DevelStage::Rendering)jarg2;
24240   {
24241     try {
24242       DevelStage::SetRenderingBehavior(*arg1,arg2);
24243     } CALL_CATCH_EXCEPTION();
24244   }
24245
24246 }
24247
24248 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Stage_GetRenderingBehavior(void * jarg1) {
24249
24250   int jresult ;
24251   int result ;
24252   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
24253
24254   arg1 = (Dali::Stage *)jarg1;
24255   {
24256     try {
24257       result = (int)(DevelStage::GetRenderingBehavior(*arg1));
24258     } CALL_CATCH_EXCEPTION(0);
24259   }
24260
24261   jresult = result;
24262   return jresult;
24263 }
24264
24265 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RelayoutContainer(void * jarg1) {
24266   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
24267
24268   arg1 = (Dali::RelayoutContainer *)jarg1;
24269   {
24270     try {
24271       delete arg1;
24272     } CALL_CATCH_EXCEPTION();
24273   }
24274
24275 }
24276
24277
24278 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) {
24279   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
24280   Dali::Actor *arg2 = 0 ;
24281   Dali::Vector2 *arg3 = 0 ;
24282
24283   arg1 = (Dali::RelayoutContainer *)jarg1;
24284   arg2 = (Dali::Actor *)jarg2;
24285   if (!arg2) {
24286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
24287     return ;
24288   }
24289   arg3 = (Dali::Vector2 *)jarg3;
24290   if (!arg3) {
24291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
24292     return ;
24293   }
24294   {
24295     try {
24296       (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3);
24297     } CALL_CATCH_EXCEPTION();
24298   }
24299
24300 }
24301
24302
24303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_Self(void * jarg1) {
24304   void * jresult ;
24305   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24306   Dali::CustomActor result;
24307
24308   arg1 = (Dali::CustomActorImpl *)jarg1;
24309   {
24310     try {
24311       result = ((Dali::CustomActorImpl const *)arg1)->Self();
24312     } CALL_CATCH_EXCEPTION(0);
24313   }
24314
24315   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
24316   return jresult;
24317 }
24318
24319
24320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSceneConnection(void * jarg1, int jarg2) {
24321   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24322   int arg2 ;
24323
24324   arg1 = (Dali::CustomActorImpl *)jarg1;
24325   arg2 = (int)jarg2;
24326   {
24327     try {
24328       (arg1)->OnSceneConnection(arg2);
24329     } CALL_CATCH_EXCEPTION();
24330   }
24331
24332 }
24333
24334
24335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSceneDisconnection(void * jarg1) {
24336   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24337
24338   arg1 = (Dali::CustomActorImpl *)jarg1;
24339   {
24340     try {
24341       (arg1)->OnSceneDisconnection();
24342     } CALL_CATCH_EXCEPTION();
24343   }
24344
24345 }
24346
24347
24348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildAdd(void * jarg1, void * jarg2) {
24349   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24350   Dali::Actor *arg2 = 0 ;
24351
24352   arg1 = (Dali::CustomActorImpl *)jarg1;
24353   arg2 = (Dali::Actor *)jarg2;
24354   if (!arg2) {
24355     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
24356     return ;
24357   }
24358   {
24359     try {
24360       (arg1)->OnChildAdd(*arg2);
24361     } CALL_CATCH_EXCEPTION();
24362   }
24363
24364 }
24365
24366
24367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) {
24368   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24369   Dali::Actor *arg2 = 0 ;
24370
24371   arg1 = (Dali::CustomActorImpl *)jarg1;
24372   arg2 = (Dali::Actor *)jarg2;
24373   if (!arg2) {
24374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
24375     return ;
24376   }
24377   {
24378     try {
24379       (arg1)->OnChildRemove(*arg2);
24380     } CALL_CATCH_EXCEPTION();
24381   }
24382
24383 }
24384
24385
24386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
24387   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24388   Dali::Property::Index arg2 ;
24389   Dali::Property::Value arg3 ;
24390   Dali::Property::Value *argp3 ;
24391
24392   arg1 = (Dali::CustomActorImpl *)jarg1;
24393   arg2 = (Dali::Property::Index)jarg2;
24394   argp3 = (Dali::Property::Value *)jarg3;
24395   if (!argp3) {
24396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
24397     return ;
24398   }
24399   arg3 = *argp3;
24400   {
24401     try {
24402       (arg1)->OnPropertySet(arg2,arg3);
24403     } CALL_CATCH_EXCEPTION();
24404   }
24405
24406 }
24407
24408
24409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeSet(void * jarg1, void * jarg2) {
24410   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24411   Dali::Vector3 *arg2 = 0 ;
24412
24413   arg1 = (Dali::CustomActorImpl *)jarg1;
24414   arg2 = (Dali::Vector3 *)jarg2;
24415   if (!arg2) {
24416     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
24417     return ;
24418   }
24419   {
24420     try {
24421       (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2);
24422     } CALL_CATCH_EXCEPTION();
24423   }
24424
24425 }
24426
24427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
24428   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24429   Dali::Animation *arg2 = 0 ;
24430   Dali::Vector3 *arg3 = 0 ;
24431
24432   arg1 = (Dali::CustomActorImpl *)jarg1;
24433   arg2 = (Dali::Animation *)jarg2;
24434   if (!arg2) {
24435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
24436     return ;
24437   }
24438   arg3 = (Dali::Vector3 *)jarg3;
24439   if (!arg3) {
24440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
24441     return ;
24442   }
24443   {
24444     try {
24445       (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
24446     } CALL_CATCH_EXCEPTION();
24447   }
24448 }
24449
24450 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnHoverEvent(void * jarg1, void * jarg2) {
24451   unsigned int jresult ;
24452   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24453   Dali::HoverEvent *arg2 = 0 ;
24454   bool result;
24455
24456   arg1 = (Dali::CustomActorImpl *)jarg1;
24457   arg2 = (Dali::HoverEvent *)jarg2;
24458   if (!arg2) {
24459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
24460     return 0;
24461   }
24462   {
24463     try {
24464       result = (bool)(arg1)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
24465     } CALL_CATCH_EXCEPTION(0);
24466   }
24467
24468   jresult = result;
24469   return jresult;
24470 }
24471
24472
24473 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnKeyEvent(void * jarg1, void * jarg2) {
24474   unsigned int jresult ;
24475   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24476   Dali::KeyEvent *arg2 = 0 ;
24477   bool result;
24478
24479   arg1 = (Dali::CustomActorImpl *)jarg1;
24480   arg2 = (Dali::KeyEvent *)jarg2;
24481   if (!arg2) {
24482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
24483     return 0;
24484   }
24485   {
24486     try {
24487       result = (bool)(arg1)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
24488     } CALL_CATCH_EXCEPTION(0);
24489   }
24490
24491   jresult = result;
24492   return jresult;
24493 }
24494
24495
24496 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnWheelEvent(void * jarg1, void * jarg2) {
24497   unsigned int jresult ;
24498   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24499   Dali::WheelEvent *arg2 = 0 ;
24500   bool result;
24501
24502   arg1 = (Dali::CustomActorImpl *)jarg1;
24503   arg2 = (Dali::WheelEvent *)jarg2;
24504   if (!arg2) {
24505     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
24506     return 0;
24507   }
24508   {
24509     try {
24510       result = (bool)(arg1)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
24511     } CALL_CATCH_EXCEPTION(0);
24512   }
24513
24514   jresult = result;
24515   return jresult;
24516 }
24517
24518
24519 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
24520   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24521   Dali::Vector2 *arg2 = 0 ;
24522   Dali::RelayoutContainer *arg3 = 0 ;
24523
24524   arg1 = (Dali::CustomActorImpl *)jarg1;
24525   arg2 = (Dali::Vector2 *)jarg2;
24526   if (!arg2) {
24527     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
24528     return ;
24529   }
24530   arg3 = (Dali::RelayoutContainer *)jarg3;
24531   if (!arg3) {
24532     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
24533     return ;
24534   }
24535   {
24536     try {
24537       (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
24538     } CALL_CATCH_EXCEPTION();
24539   }
24540
24541 }
24542
24543
24544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
24545   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24546   Dali::ResizePolicy::Type arg2 ;
24547   Dali::Dimension::Type arg3 ;
24548
24549   arg1 = (Dali::CustomActorImpl *)jarg1;
24550   arg2 = (Dali::ResizePolicy::Type)jarg2;
24551   arg3 = (Dali::Dimension::Type)jarg3;
24552   {
24553     try {
24554       (arg1)->OnSetResizePolicy(arg2,arg3);
24555     } CALL_CATCH_EXCEPTION();
24556   }
24557
24558 }
24559
24560
24561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetNaturalSize(void * jarg1) {
24562   void * jresult ;
24563   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24564   Dali::Vector3 result;
24565
24566   arg1 = (Dali::CustomActorImpl *)jarg1;
24567   {
24568     try {
24569       result = (arg1)->GetNaturalSize();
24570     } CALL_CATCH_EXCEPTION(0);
24571   }
24572
24573   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
24574   return jresult;
24575 }
24576
24577
24578 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
24579   float jresult ;
24580   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24581   Dali::Actor *arg2 = 0 ;
24582   Dali::Dimension::Type arg3 ;
24583   float result;
24584
24585   arg1 = (Dali::CustomActorImpl *)jarg1;
24586   arg2 = (Dali::Actor *)jarg2;
24587   if (!arg2) {
24588     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
24589     return 0;
24590   }
24591   arg3 = (Dali::Dimension::Type)jarg3;
24592   {
24593     try {
24594       result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
24595     } CALL_CATCH_EXCEPTION(0);
24596   }
24597
24598   jresult = result;
24599   return jresult;
24600 }
24601
24602
24603 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) {
24604   float jresult ;
24605   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24606   float arg2 ;
24607   float result;
24608
24609   arg1 = (Dali::CustomActorImpl *)jarg1;
24610   arg2 = (float)jarg2;
24611   {
24612     try {
24613       result = (float)(arg1)->GetHeightForWidth(arg2);
24614     } CALL_CATCH_EXCEPTION(0);
24615   }
24616
24617   jresult = result;
24618   return jresult;
24619 }
24620
24621
24622 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) {
24623   float jresult ;
24624   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24625   float arg2 ;
24626   float result;
24627
24628   arg1 = (Dali::CustomActorImpl *)jarg1;
24629   arg2 = (float)jarg2;
24630   {
24631     try {
24632       result = (float)(arg1)->GetWidthForHeight(arg2);
24633     } CALL_CATCH_EXCEPTION(0);
24634   }
24635
24636   jresult = result;
24637   return jresult;
24638 }
24639
24640
24641 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
24642   unsigned int jresult ;
24643   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24644   Dali::Dimension::Type arg2 ;
24645   bool result;
24646
24647   arg1 = (Dali::CustomActorImpl *)jarg1;
24648   arg2 = (Dali::Dimension::Type)jarg2;
24649   {
24650     try {
24651       result = (bool)(arg1)->RelayoutDependentOnChildren(arg2);
24652     } CALL_CATCH_EXCEPTION(0);
24653   }
24654
24655   jresult = result;
24656   return jresult;
24657 }
24658
24659
24660 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
24661   unsigned int jresult ;
24662   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24663   bool result;
24664
24665   arg1 = (Dali::CustomActorImpl *)jarg1;
24666   {
24667     try {
24668       result = (bool)(arg1)->RelayoutDependentOnChildren();
24669     } CALL_CATCH_EXCEPTION(0);
24670   }
24671
24672   jresult = result;
24673   return jresult;
24674 }
24675
24676
24677 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
24678   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24679   Dali::Dimension::Type arg2 ;
24680
24681   arg1 = (Dali::CustomActorImpl *)jarg1;
24682   arg2 = (Dali::Dimension::Type)jarg2;
24683   {
24684     try {
24685       (arg1)->OnCalculateRelayoutSize(arg2);
24686     } CALL_CATCH_EXCEPTION();
24687   }
24688
24689 }
24690
24691
24692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
24693   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24694   float arg2 ;
24695   Dali::Dimension::Type arg3 ;
24696
24697   arg1 = (Dali::CustomActorImpl *)jarg1;
24698   arg2 = (float)jarg2;
24699   arg3 = (Dali::Dimension::Type)jarg3;
24700   {
24701     try {
24702       (arg1)->OnLayoutNegotiated(arg2,arg3);
24703     } CALL_CATCH_EXCEPTION();
24704   }
24705
24706 }
24707
24708
24709 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresTouchEvents(void * jarg1) {
24710   unsigned int jresult ;
24711   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24712   bool result;
24713
24714   arg1 = (Dali::CustomActorImpl *)jarg1;
24715   {
24716     try {
24717       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresTouchEvents();
24718     } CALL_CATCH_EXCEPTION(0);
24719   }
24720
24721   jresult = result;
24722   return jresult;
24723 }
24724
24725
24726 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresHoverEvents(void * jarg1) {
24727   unsigned int jresult ;
24728   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24729   bool result;
24730
24731   arg1 = (Dali::CustomActorImpl *)jarg1;
24732   {
24733     try {
24734       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresHoverEvents();
24735     } CALL_CATCH_EXCEPTION(0);
24736   }
24737
24738   jresult = result;
24739   return jresult;
24740 }
24741
24742
24743 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresWheelEvents(void * jarg1) {
24744   unsigned int jresult ;
24745   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24746   bool result;
24747
24748   arg1 = (Dali::CustomActorImpl *)jarg1;
24749   {
24750     try {
24751       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresWheelEvents();
24752     } CALL_CATCH_EXCEPTION(0);
24753   }
24754
24755   jresult = result;
24756   return jresult;
24757 }
24758
24759
24760 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_IsRelayoutEnabled(void * jarg1) {
24761   unsigned int jresult ;
24762   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24763   bool result;
24764
24765   arg1 = (Dali::CustomActorImpl *)jarg1;
24766   {
24767     try {
24768       result = (bool)((Dali::CustomActorImpl const *)arg1)->IsRelayoutEnabled();
24769     } CALL_CATCH_EXCEPTION(0);
24770   }
24771
24772   jresult = result;
24773   return jresult;
24774 }
24775
24776
24777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_0() {
24778   void * jresult ;
24779   Dali::CustomActor *result = 0 ;
24780
24781   {
24782     try {
24783       result = (Dali::CustomActor *)new Dali::CustomActor();
24784     } CALL_CATCH_EXCEPTION(0);
24785   }
24786
24787   jresult = (void *)result;
24788   return jresult;
24789 }
24790
24791
24792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_DownCast(void * jarg1) {
24793   void * jresult ;
24794   Dali::BaseHandle arg1 ;
24795   Dali::BaseHandle *argp1 ;
24796   Dali::CustomActor result;
24797
24798   argp1 = (Dali::BaseHandle *)jarg1;
24799   if (!argp1) {
24800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24801     return 0;
24802   }
24803   arg1 = *argp1;
24804   {
24805     try {
24806       result = Dali::CustomActor::DownCast(arg1);
24807     } CALL_CATCH_EXCEPTION(0);
24808   }
24809
24810   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
24811   return jresult;
24812 }
24813
24814
24815 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomActor(void * jarg1) {
24816   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
24817
24818   arg1 = (Dali::CustomActor *)jarg1;
24819   {
24820     try {
24821       delete arg1;
24822     } CALL_CATCH_EXCEPTION();
24823   }
24824
24825 }
24826
24827
24828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_GetImplementation(void * jarg1) {
24829   void * jresult ;
24830   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
24831   Dali::CustomActorImpl *result = 0 ;
24832
24833   arg1 = (Dali::CustomActor *)jarg1;
24834   {
24835     try {
24836       result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation();
24837     } CALL_CATCH_EXCEPTION(0);
24838   }
24839
24840   jresult = (void *)result;
24841   return jresult;
24842 }
24843
24844
24845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_1(void * jarg1) {
24846   void * jresult ;
24847   Dali::CustomActorImpl *arg1 = 0 ;
24848   Dali::CustomActor *result = 0 ;
24849
24850   arg1 = (Dali::CustomActorImpl *)jarg1;
24851   if (!arg1) {
24852     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0);
24853     return 0;
24854   }
24855   {
24856     try {
24857       result = (Dali::CustomActor *)new Dali::CustomActor(*arg1);
24858     } CALL_CATCH_EXCEPTION(0);
24859   }
24860
24861   jresult = (void *)result;
24862   return jresult;
24863 }
24864
24865
24866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_2(void * jarg1) {
24867   void * jresult ;
24868   Dali::CustomActor *arg1 = 0 ;
24869   Dali::CustomActor *result = 0 ;
24870
24871   arg1 = (Dali::CustomActor *)jarg1;
24872   if (!arg1) {
24873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
24874     return 0;
24875   }
24876   {
24877     try {
24878       result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*arg1);
24879     } CALL_CATCH_EXCEPTION(0);
24880   }
24881
24882   jresult = (void *)result;
24883   return jresult;
24884 }
24885
24886
24887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_Assign(void * jarg1, void * jarg2) {
24888   void * jresult ;
24889   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
24890   Dali::CustomActor *arg2 = 0 ;
24891   Dali::CustomActor *result = 0 ;
24892
24893   arg1 = (Dali::CustomActor *)jarg1;
24894   arg2 = (Dali::CustomActor *)jarg2;
24895   if (!arg2) {
24896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
24897     return 0;
24898   }
24899   {
24900     try {
24901       result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2);
24902     } CALL_CATCH_EXCEPTION(0);
24903   }
24904
24905   jresult = (void *)result;
24906   return jresult;
24907 }
24908
24909
24910 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_POSITION_get() {
24911   int jresult ;
24912   int result;
24913
24914   result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION;
24915   jresult = (int)result;
24916   return jresult;
24917 }
24918
24919
24920 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() {
24921   int jresult ;
24922   int result;
24923
24924   result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT;
24925   jresult = (int)result;
24926   return jresult;
24927 }
24928
24929
24930 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_VELOCITY_get() {
24931   int jresult ;
24932   int result;
24933
24934   result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY;
24935   jresult = (int)result;
24936   return jresult;
24937 }
24938
24939
24940 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_POSITION_get() {
24941   int jresult ;
24942   int result;
24943
24944   result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION;
24945   jresult = (int)result;
24946   return jresult;
24947 }
24948
24949
24950 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() {
24951   int jresult ;
24952   int result;
24953
24954   result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT;
24955   jresult = (int)result;
24956   return jresult;
24957 }
24958
24959
24960 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_VELOCITY_get() {
24961   int jresult ;
24962   int result;
24963
24964   result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY;
24965   jresult = (int)result;
24966   return jresult;
24967 }
24968
24969
24970 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_PANNING_get() {
24971   int jresult ;
24972   int result;
24973
24974   result = (int)Dali::PanGestureDetector::Property::PANNING;
24975   jresult = (int)result;
24976   return jresult;
24977 }
24978
24979
24980 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector_Property() {
24981   void * jresult ;
24982   Dali::PanGestureDetector::Property *result = 0 ;
24983
24984   {
24985     try {
24986       result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property();
24987     } CALL_CATCH_EXCEPTION(0);
24988   }
24989
24990   jresult = (void *)result;
24991   return jresult;
24992 }
24993
24994
24995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector_Property(void * jarg1) {
24996   Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ;
24997
24998   arg1 = (Dali::PanGestureDetector::Property *)jarg1;
24999   {
25000     try {
25001       delete arg1;
25002     } CALL_CATCH_EXCEPTION();
25003   }
25004
25005 }
25006
25007
25008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_LEFT_get() {
25009   void * jresult ;
25010   Dali::Radian *result = 0 ;
25011
25012   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT;
25013   jresult = (void *)result;
25014   return jresult;
25015 }
25016
25017
25018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_RIGHT_get() {
25019   void * jresult ;
25020   Dali::Radian *result = 0 ;
25021
25022   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT;
25023   jresult = (void *)result;
25024   return jresult;
25025 }
25026
25027
25028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_UP_get() {
25029   void * jresult ;
25030   Dali::Radian *result = 0 ;
25031
25032   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP;
25033   jresult = (void *)result;
25034   return jresult;
25035 }
25036
25037
25038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_DOWN_get() {
25039   void * jresult ;
25040   Dali::Radian *result = 0 ;
25041
25042   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN;
25043   jresult = (void *)result;
25044   return jresult;
25045 }
25046
25047
25048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_HORIZONTAL_get() {
25049   void * jresult ;
25050   Dali::Radian *result = 0 ;
25051
25052   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL;
25053   jresult = (void *)result;
25054   return jresult;
25055 }
25056
25057
25058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_VERTICAL_get() {
25059   void * jresult ;
25060   Dali::Radian *result = 0 ;
25061
25062   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL;
25063   jresult = (void *)result;
25064   return jresult;
25065 }
25066
25067
25068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DEFAULT_THRESHOLD_get() {
25069   void * jresult ;
25070   Dali::Radian *result = 0 ;
25071
25072   result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD;
25073   jresult = (void *)result;
25074   return jresult;
25075 }
25076
25077
25078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_0() {
25079   void * jresult ;
25080   Dali::PanGestureDetector *result = 0 ;
25081
25082   {
25083     try {
25084       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector();
25085     } CALL_CATCH_EXCEPTION(0);
25086   }
25087
25088   jresult = (void *)result;
25089   return jresult;
25090 }
25091
25092
25093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_New() {
25094   void * jresult ;
25095   Dali::PanGestureDetector result;
25096
25097   {
25098     try {
25099       result = Dali::PanGestureDetector::New();
25100     } CALL_CATCH_EXCEPTION(0);
25101   }
25102
25103   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
25104   return jresult;
25105 }
25106
25107
25108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DownCast(void * jarg1) {
25109   void * jresult ;
25110   Dali::BaseHandle arg1 ;
25111   Dali::BaseHandle *argp1 ;
25112   Dali::PanGestureDetector result;
25113
25114   argp1 = (Dali::BaseHandle *)jarg1;
25115   if (!argp1) {
25116     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25117     return 0;
25118   }
25119   arg1 = *argp1;
25120   {
25121     try {
25122       result = Dali::PanGestureDetector::DownCast(arg1);
25123     } CALL_CATCH_EXCEPTION(0);
25124   }
25125
25126   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
25127   return jresult;
25128 }
25129
25130
25131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector(void * jarg1) {
25132   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25133
25134   arg1 = (Dali::PanGestureDetector *)jarg1;
25135   {
25136     try {
25137       delete arg1;
25138     } CALL_CATCH_EXCEPTION();
25139   }
25140
25141 }
25142
25143
25144 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_1(void * jarg1) {
25145   void * jresult ;
25146   Dali::PanGestureDetector *arg1 = 0 ;
25147   Dali::PanGestureDetector *result = 0 ;
25148
25149   arg1 = (Dali::PanGestureDetector *)jarg1;
25150   if (!arg1) {
25151     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
25152     return 0;
25153   }
25154   {
25155     try {
25156       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1);
25157     } CALL_CATCH_EXCEPTION(0);
25158   }
25159
25160   jresult = (void *)result;
25161   return jresult;
25162 }
25163
25164
25165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_Assign(void * jarg1, void * jarg2) {
25166   void * jresult ;
25167   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25168   Dali::PanGestureDetector *arg2 = 0 ;
25169   Dali::PanGestureDetector *result = 0 ;
25170
25171   arg1 = (Dali::PanGestureDetector *)jarg1;
25172   arg2 = (Dali::PanGestureDetector *)jarg2;
25173   if (!arg2) {
25174     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
25175     return 0;
25176   }
25177   {
25178     try {
25179       result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2);
25180     } CALL_CATCH_EXCEPTION(0);
25181   }
25182
25183   jresult = (void *)result;
25184   return jresult;
25185 }
25186
25187
25188 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) {
25189   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25190   unsigned int arg2 ;
25191
25192   arg1 = (Dali::PanGestureDetector *)jarg1;
25193   arg2 = (unsigned int)jarg2;
25194   {
25195     try {
25196       (arg1)->SetMinimumTouchesRequired(arg2);
25197     } CALL_CATCH_EXCEPTION();
25198   }
25199
25200 }
25201
25202
25203 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) {
25204   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25205   unsigned int arg2 ;
25206
25207   arg1 = (Dali::PanGestureDetector *)jarg1;
25208   arg2 = (unsigned int)jarg2;
25209   {
25210     try {
25211       (arg1)->SetMaximumTouchesRequired(arg2);
25212     } CALL_CATCH_EXCEPTION();
25213   }
25214
25215 }
25216
25217
25218 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
25219   unsigned int jresult ;
25220   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25221   unsigned int result;
25222
25223   arg1 = (Dali::PanGestureDetector *)jarg1;
25224   {
25225     try {
25226       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired();
25227     } CALL_CATCH_EXCEPTION(0);
25228   }
25229
25230   jresult = result;
25231   return jresult;
25232 }
25233
25234
25235 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
25236   unsigned int jresult ;
25237   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25238   unsigned int result;
25239
25240   arg1 = (Dali::PanGestureDetector *)jarg1;
25241   {
25242     try {
25243       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMaximumTouchesRequired();
25244     } CALL_CATCH_EXCEPTION(0);
25245   }
25246
25247   jresult = result;
25248   return jresult;
25249 }
25250
25251
25252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
25253   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25254   Dali::Radian arg2 ;
25255   Dali::Radian arg3 ;
25256   Dali::Radian *argp2 ;
25257   Dali::Radian *argp3 ;
25258
25259   arg1 = (Dali::PanGestureDetector *)jarg1;
25260   argp2 = (Dali::Radian *)jarg2;
25261   if (!argp2) {
25262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
25263     return ;
25264   }
25265   arg2 = *argp2;
25266   argp3 = (Dali::Radian *)jarg3;
25267   if (!argp3) {
25268     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
25269     return ;
25270   }
25271   arg3 = *argp3;
25272   {
25273     try {
25274       (arg1)->AddAngle(arg2,arg3);
25275     } CALL_CATCH_EXCEPTION();
25276   }
25277
25278 }
25279
25280
25281 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) {
25282   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25283   Dali::Radian arg2 ;
25284   Dali::Radian *argp2 ;
25285
25286   arg1 = (Dali::PanGestureDetector *)jarg1;
25287   argp2 = (Dali::Radian *)jarg2;
25288   if (!argp2) {
25289     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
25290     return ;
25291   }
25292   arg2 = *argp2;
25293   {
25294     try {
25295       (arg1)->AddAngle(arg2);
25296     } CALL_CATCH_EXCEPTION();
25297   }
25298
25299 }
25300
25301
25302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
25303   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25304   Dali::Radian arg2 ;
25305   Dali::Radian arg3 ;
25306   Dali::Radian *argp2 ;
25307   Dali::Radian *argp3 ;
25308
25309   arg1 = (Dali::PanGestureDetector *)jarg1;
25310   argp2 = (Dali::Radian *)jarg2;
25311   if (!argp2) {
25312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
25313     return ;
25314   }
25315   arg2 = *argp2;
25316   argp3 = (Dali::Radian *)jarg3;
25317   if (!argp3) {
25318     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
25319     return ;
25320   }
25321   arg3 = *argp3;
25322   {
25323     try {
25324       (arg1)->AddDirection(arg2,arg3);
25325     } CALL_CATCH_EXCEPTION();
25326   }
25327
25328 }
25329
25330
25331 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) {
25332   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25333   Dali::Radian arg2 ;
25334   Dali::Radian *argp2 ;
25335
25336   arg1 = (Dali::PanGestureDetector *)jarg1;
25337   argp2 = (Dali::Radian *)jarg2;
25338   if (!argp2) {
25339     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
25340     return ;
25341   }
25342   arg2 = *argp2;
25343   {
25344     try {
25345       (arg1)->AddDirection(arg2);
25346     } CALL_CATCH_EXCEPTION();
25347   }
25348
25349 }
25350
25351
25352 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngleCount(void * jarg1) {
25353   unsigned long jresult ;
25354   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25355   size_t result;
25356
25357   arg1 = (Dali::PanGestureDetector *)jarg1;
25358   {
25359     try {
25360       result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount();
25361     } CALL_CATCH_EXCEPTION(0);
25362   }
25363
25364   jresult = (unsigned long)result;
25365   return jresult;
25366 }
25367
25368
25369 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) {
25370   void * jresult ;
25371   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25372   size_t arg2 ;
25373   Dali::PanGestureDetector::AngleThresholdPair result;
25374
25375   arg1 = (Dali::PanGestureDetector *)jarg1;
25376   arg2 = (size_t)jarg2;
25377   {
25378     try {
25379       result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2);
25380     } CALL_CATCH_EXCEPTION(0);
25381   }
25382
25383   jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result);
25384   return jresult;
25385 }
25386
25387
25388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_ClearAngles(void * jarg1) {
25389   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25390
25391   arg1 = (Dali::PanGestureDetector *)jarg1;
25392   {
25393     try {
25394       (arg1)->ClearAngles();
25395     } CALL_CATCH_EXCEPTION();
25396   }
25397
25398 }
25399
25400
25401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) {
25402   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25403   Dali::Radian arg2 ;
25404   Dali::Radian *argp2 ;
25405
25406   arg1 = (Dali::PanGestureDetector *)jarg1;
25407   argp2 = (Dali::Radian *)jarg2;
25408   if (!argp2) {
25409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
25410     return ;
25411   }
25412   arg2 = *argp2;
25413   {
25414     try {
25415       (arg1)->RemoveAngle(arg2);
25416     } CALL_CATCH_EXCEPTION();
25417   }
25418
25419 }
25420
25421
25422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveDirection(void * jarg1, void * jarg2) {
25423   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25424   Dali::Radian arg2 ;
25425   Dali::Radian *argp2 ;
25426
25427   arg1 = (Dali::PanGestureDetector *)jarg1;
25428   argp2 = (Dali::Radian *)jarg2;
25429   if (!argp2) {
25430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
25431     return ;
25432   }
25433   arg2 = *argp2;
25434   {
25435     try {
25436       (arg1)->RemoveDirection(arg2);
25437     } CALL_CATCH_EXCEPTION();
25438   }
25439
25440 }
25441
25442
25443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DetectedSignal(void * jarg1) {
25444   void * jresult ;
25445   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25446   Dali::PanGestureDetector::DetectedSignalType *result = 0 ;
25447
25448   arg1 = (Dali::PanGestureDetector *)jarg1;
25449   {
25450     try {
25451       result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
25452     } CALL_CATCH_EXCEPTION(0);
25453   }
25454
25455   jresult = (void *)result;
25456   return jresult;
25457 }
25458
25459
25460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetPanGestureProperties(void * jarg1) {
25461   Dali::PanGesture *arg1 = 0 ;
25462
25463   arg1 = (Dali::PanGesture *)jarg1;
25464   if (!arg1) {
25465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
25466     return ;
25467   }
25468   {
25469     try {
25470       Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1);
25471     } CALL_CATCH_EXCEPTION();
25472   }
25473
25474 }
25475
25476
25477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_0() {
25478   void * jresult ;
25479   Dali::PanGesture *result = 0 ;
25480
25481   {
25482     try {
25483       result = (Dali::PanGesture *)new Dali::PanGesture();
25484     } CALL_CATCH_EXCEPTION(0);
25485   }
25486
25487   jresult = (void *)result;
25488   return jresult;
25489 }
25490
25491 // Need to delete this
25492 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_1(int jarg1) {
25493   void * jresult ;
25494   Dali::Gesture::State arg1 ;
25495   Dali::PanGesture *result = 0 ;
25496
25497   arg1 = (Dali::Gesture::State)jarg1;
25498   {
25499     try {
25500       result = (Dali::PanGesture *)new Dali::PanGesture();
25501     } catch (std::out_of_range& e) {
25502       {
25503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25504       };
25505     } catch (std::exception& e) {
25506       {
25507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25508       };
25509     } catch (Dali::DaliException e) {
25510       {
25511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25512       };
25513     } catch (...) {
25514       {
25515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25516       };
25517     }
25518   }
25519
25520   jresult = (void *)result;
25521   return jresult;
25522 }
25523
25524
25525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_2(void * jarg1) {
25526   void * jresult ;
25527   Dali::PanGesture *arg1 = 0 ;
25528   Dali::PanGesture *result = 0 ;
25529
25530   arg1 = (Dali::PanGesture *)jarg1;
25531   if (!arg1) {
25532     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
25533     return 0;
25534   }
25535   {
25536     try {
25537       result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*arg1);
25538     } CALL_CATCH_EXCEPTION(0);
25539   }
25540
25541   jresult = (void *)result;
25542   return jresult;
25543 }
25544
25545
25546 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_Assign(void * jarg1, void * jarg2) {
25547   void * jresult ;
25548   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
25549   Dali::PanGesture *arg2 = 0 ;
25550   Dali::PanGesture *result = 0 ;
25551
25552   arg1 = (Dali::PanGesture *)jarg1;
25553   arg2 = (Dali::PanGesture *)jarg2;
25554   if (!arg2) {
25555     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
25556     return 0;
25557   }
25558   {
25559     try {
25560       result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2);
25561     } CALL_CATCH_EXCEPTION(0);
25562   }
25563
25564   jresult = (void *)result;
25565   return jresult;
25566 }
25567
25568
25569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGesture(void * jarg1) {
25570   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
25571
25572   arg1 = (Dali::PanGesture *)jarg1;
25573   {
25574     try {
25575       delete arg1;
25576     } CALL_CATCH_EXCEPTION();
25577   }
25578
25579 }
25580
25581
25582 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_velocity_get(void * jarg1) {
25583   void * jresult ;
25584   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
25585   Dali::Vector2 result;
25586
25587   arg1 = (Dali::PanGesture *)jarg1;
25588   {
25589     try {
25590       result = ((Dali::PanGesture const *)arg1)->GetVelocity();
25591     } catch (std::out_of_range& e) {
25592       {
25593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25594       };
25595     } catch (std::exception& e) {
25596       {
25597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25598       };
25599     } catch (Dali::DaliException e) {
25600       {
25601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25602       };
25603     } catch (...) {
25604       {
25605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25606       };
25607     }
25608   }
25609   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
25610   return jresult;
25611 }
25612
25613
25614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_displacement_get(void * jarg1) {
25615   void * jresult ;
25616   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
25617   Dali::Vector2 result;
25618
25619   arg1 = (Dali::PanGesture *)jarg1;
25620   {
25621     try {
25622       result = ((Dali::PanGesture const *)arg1)->GetDisplacement();
25623     } catch (std::out_of_range& e) {
25624       {
25625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25626       };
25627     } catch (std::exception& e) {
25628       {
25629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25630       };
25631     } catch (Dali::DaliException e) {
25632       {
25633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25634       };
25635     } catch (...) {
25636       {
25637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25638       };
25639     }
25640   }
25641   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
25642   return jresult;
25643 }
25644
25645
25646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_position_get(void * jarg1) {
25647   void * jresult ;
25648   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
25649   Dali::Vector2 result;
25650
25651   arg1 = (Dali::PanGesture *)jarg1;
25652   {
25653     try {
25654       result = ((Dali::PanGesture const *)arg1)->GetPosition();
25655     } catch (std::out_of_range& e) {
25656       {
25657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25658       };
25659     } catch (std::exception& e) {
25660       {
25661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25662       };
25663     } catch (Dali::DaliException e) {
25664       {
25665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25666       };
25667     } catch (...) {
25668       {
25669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25670       };
25671     }
25672   }
25673   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
25674   return jresult;
25675 }
25676
25677 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_get(void * jarg1) {
25678   void * jresult ;
25679   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
25680   Dali::Vector2 result;
25681
25682   arg1 = (Dali::PanGesture *)jarg1;
25683   {
25684     try {
25685       result = ((Dali::PanGesture const *)arg1)->GetScreenVelocity();
25686     } catch (std::out_of_range& e) {
25687       {
25688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25689       };
25690     } catch (std::exception& e) {
25691       {
25692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25693       };
25694     } catch (Dali::DaliException e) {
25695       {
25696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25697       };
25698     } catch (...) {
25699       {
25700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25701       };
25702     }
25703   }
25704   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
25705   return jresult;
25706 }
25707
25708
25709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_get(void * jarg1) {
25710   void * jresult ;
25711   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
25712   Dali::Vector2 result;
25713
25714   arg1 = (Dali::PanGesture *)jarg1;
25715   {
25716     try {
25717       result = ((Dali::PanGesture const *)arg1)->GetScreenDisplacement();
25718     } catch (std::out_of_range& e) {
25719       {
25720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25721       };
25722     } catch (std::exception& e) {
25723       {
25724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25725       };
25726     } catch (Dali::DaliException e) {
25727       {
25728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25729       };
25730     } catch (...) {
25731       {
25732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25733       };
25734     }
25735   }
25736   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
25737   return jresult;
25738 }
25739
25740
25741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_get(void * jarg1) {
25742   void * jresult ;
25743   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
25744   Dali::Vector2 result;
25745
25746   arg1 = (Dali::PanGesture *)jarg1;
25747   {
25748     try {
25749       result = ((Dali::PanGesture const *)arg1)->GetScreenPosition();
25750     } catch (std::out_of_range& e) {
25751       {
25752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25753       };
25754     } catch (std::exception& e) {
25755       {
25756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25757       };
25758     } catch (Dali::DaliException e) {
25759       {
25760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25761       };
25762     } catch (...) {
25763       {
25764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25765       };
25766     }
25767   }
25768   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
25769   return jresult;
25770 }
25771
25772
25773 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_get(void * jarg1) {
25774   unsigned int jresult ;
25775   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
25776   unsigned int result;
25777
25778   arg1 = (Dali::PanGesture *)jarg1;
25779   result = (unsigned int) ((arg1)->GetNumberOfTouches());
25780   jresult = result;
25781   return jresult;
25782 }
25783
25784
25785 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetSpeed(void * jarg1) {
25786   float jresult ;
25787   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
25788   float result;
25789
25790   arg1 = (Dali::PanGesture *)jarg1;
25791   {
25792     try {
25793       result = (float)((Dali::PanGesture const *)arg1)->GetSpeed();
25794     } CALL_CATCH_EXCEPTION(0);
25795   }
25796
25797   jresult = result;
25798   return jresult;
25799 }
25800
25801
25802 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetDistance(void * jarg1) {
25803   float jresult ;
25804   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
25805   float result;
25806
25807   arg1 = (Dali::PanGesture *)jarg1;
25808   {
25809     try {
25810       result = (float)((Dali::PanGesture const *)arg1)->GetDistance();
25811     } CALL_CATCH_EXCEPTION(0);
25812   }
25813
25814   jresult = result;
25815   return jresult;
25816 }
25817
25818
25819 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenSpeed(void * jarg1) {
25820   float jresult ;
25821   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
25822   float result;
25823
25824   arg1 = (Dali::PanGesture *)jarg1;
25825   {
25826     try {
25827       result = (float)((Dali::PanGesture const *)arg1)->GetScreenSpeed();
25828     } CALL_CATCH_EXCEPTION(0);
25829   }
25830
25831   jresult = result;
25832   return jresult;
25833 }
25834
25835
25836 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenDistance(void * jarg1) {
25837   float jresult ;
25838   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
25839   float result;
25840
25841   arg1 = (Dali::PanGesture *)jarg1;
25842   {
25843     try {
25844       result = (float)((Dali::PanGesture const *)arg1)->GetScreenDistance();
25845     } CALL_CATCH_EXCEPTION(0);
25846   }
25847
25848   jresult = result;
25849   return jresult;
25850 }
25851
25852
25853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_0() {
25854   void * jresult ;
25855   Dali::PinchGestureDetector *result = 0 ;
25856
25857   {
25858     try {
25859       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector();
25860     } CALL_CATCH_EXCEPTION(0);
25861   }
25862
25863   jresult = (void *)result;
25864   return jresult;
25865 }
25866
25867
25868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_New() {
25869   void * jresult ;
25870   Dali::PinchGestureDetector result;
25871
25872   {
25873     try {
25874       result = Dali::PinchGestureDetector::New();
25875     } CALL_CATCH_EXCEPTION(0);
25876   }
25877
25878   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
25879   return jresult;
25880 }
25881
25882
25883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DownCast(void * jarg1) {
25884   void * jresult ;
25885   Dali::BaseHandle arg1 ;
25886   Dali::BaseHandle *argp1 ;
25887   Dali::PinchGestureDetector result;
25888
25889   argp1 = (Dali::BaseHandle *)jarg1;
25890   if (!argp1) {
25891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25892     return 0;
25893   }
25894   arg1 = *argp1;
25895   {
25896     try {
25897       result = Dali::PinchGestureDetector::DownCast(arg1);
25898     } CALL_CATCH_EXCEPTION(0);
25899   }
25900
25901   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
25902   return jresult;
25903 }
25904
25905
25906 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetector(void * jarg1) {
25907   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
25908
25909   arg1 = (Dali::PinchGestureDetector *)jarg1;
25910   {
25911     try {
25912       delete arg1;
25913     } CALL_CATCH_EXCEPTION();
25914   }
25915
25916 }
25917
25918
25919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_1(void * jarg1) {
25920   void * jresult ;
25921   Dali::PinchGestureDetector *arg1 = 0 ;
25922   Dali::PinchGestureDetector *result = 0 ;
25923
25924   arg1 = (Dali::PinchGestureDetector *)jarg1;
25925   if (!arg1) {
25926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
25927     return 0;
25928   }
25929   {
25930     try {
25931       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1);
25932     } CALL_CATCH_EXCEPTION(0);
25933   }
25934
25935   jresult = (void *)result;
25936   return jresult;
25937 }
25938
25939
25940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_Assign(void * jarg1, void * jarg2) {
25941   void * jresult ;
25942   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
25943   Dali::PinchGestureDetector *arg2 = 0 ;
25944   Dali::PinchGestureDetector *result = 0 ;
25945
25946   arg1 = (Dali::PinchGestureDetector *)jarg1;
25947   arg2 = (Dali::PinchGestureDetector *)jarg2;
25948   if (!arg2) {
25949     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
25950     return 0;
25951   }
25952   {
25953     try {
25954       result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2);
25955     } CALL_CATCH_EXCEPTION(0);
25956   }
25957
25958   jresult = (void *)result;
25959   return jresult;
25960 }
25961
25962
25963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DetectedSignal(void * jarg1) {
25964   void * jresult ;
25965   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
25966   Dali::PinchGestureDetector::DetectedSignalType *result = 0 ;
25967
25968   arg1 = (Dali::PinchGestureDetector *)jarg1;
25969   {
25970     try {
25971       result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
25972     } CALL_CATCH_EXCEPTION(0);
25973   }
25974
25975   jresult = (void *)result;
25976   return jresult;
25977 }
25978
25979
25980 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_0() {
25981   void * jresult ;
25982   Dali::PinchGesture *result = 0 ;
25983
25984   {
25985     try {
25986       result = (Dali::PinchGesture *)new Dali::PinchGesture();
25987     } CALL_CATCH_EXCEPTION(0);
25988   }
25989
25990   jresult = (void *)result;
25991   return jresult;
25992 }
25993
25994
25995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_1(void * jarg1) {
25996   void * jresult ;
25997   Dali::PinchGesture *arg1 = 0 ;
25998   Dali::PinchGesture *result = 0 ;
25999
26000   arg1 = (Dali::PinchGesture *)jarg1;
26001   if (!arg1) {
26002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
26003     return 0;
26004   }
26005   {
26006     try {
26007       result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*arg1);
26008     } CALL_CATCH_EXCEPTION(0);
26009   }
26010
26011   jresult = (void *)result;
26012   return jresult;
26013 }
26014
26015
26016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_Assign(void * jarg1, void * jarg2) {
26017   void * jresult ;
26018   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
26019   Dali::PinchGesture *arg2 = 0 ;
26020   Dali::PinchGesture *result = 0 ;
26021
26022   arg1 = (Dali::PinchGesture *)jarg1;
26023   arg2 = (Dali::PinchGesture *)jarg2;
26024   if (!arg2) {
26025     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
26026     return 0;
26027   }
26028   {
26029     try {
26030       result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2);
26031     } CALL_CATCH_EXCEPTION(0);
26032   }
26033
26034   jresult = (void *)result;
26035   return jresult;
26036 }
26037
26038
26039 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGesture(void * jarg1) {
26040   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
26041
26042   arg1 = (Dali::PinchGesture *)jarg1;
26043   {
26044     try {
26045       delete arg1;
26046     } CALL_CATCH_EXCEPTION();
26047   }
26048
26049 }
26050
26051
26052 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_scale_get(void * jarg1) {
26053   float jresult ;
26054   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
26055   float result;
26056
26057   arg1 = (Dali::PinchGesture *)jarg1;
26058   result = (float) ((arg1)->GetScale());
26059   jresult = result;
26060   return jresult;
26061 }
26062
26063
26064 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_speed_get(void * jarg1) {
26065   float jresult ;
26066   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
26067   float result;
26068
26069   arg1 = (Dali::PinchGesture *)jarg1;
26070   result = (float) ((arg1)->GetSpeed());
26071   jresult = result;
26072   return jresult;
26073 }
26074
26075
26076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_get(void * jarg1) {
26077   void * jresult ;
26078   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
26079   Dali::Vector2 result;
26080
26081   arg1 = (Dali::PinchGesture *)jarg1;
26082   {
26083     try {
26084       result = ((Dali::PinchGesture const *)arg1)->GetScreenCenterPoint();
26085     } catch (std::out_of_range& e) {
26086       {
26087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26088       };
26089     } catch (std::exception& e) {
26090       {
26091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26092       };
26093     } catch (Dali::DaliException e) {
26094       {
26095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26096       };
26097     } catch (...) {
26098       {
26099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26100       };
26101     }
26102   }
26103   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
26104   return jresult;
26105 }
26106
26107
26108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_get(void * jarg1) {
26109   void * jresult ;
26110   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
26111   Dali::Vector2 result;
26112
26113   arg1 = (Dali::PinchGesture *)jarg1;
26114   {
26115     try {
26116       result = ((Dali::PinchGesture const *)arg1)->GetLocalCenterPoint();
26117     } catch (std::out_of_range& e) {
26118       {
26119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26120       };
26121     } catch (std::exception& e) {
26122       {
26123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26124       };
26125     } catch (Dali::DaliException e) {
26126       {
26127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26128       };
26129     } catch (...) {
26130       {
26131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26132       };
26133     }
26134   }
26135   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
26136   return jresult;
26137 }
26138
26139
26140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_0() {
26141   void * jresult ;
26142   Dali::TapGestureDetector *result = 0 ;
26143
26144   {
26145     try {
26146       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector();
26147     } CALL_CATCH_EXCEPTION(0);
26148   }
26149
26150   jresult = (void *)result;
26151   return jresult;
26152 }
26153
26154
26155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_0() {
26156   void * jresult ;
26157   Dali::TapGestureDetector result;
26158
26159   {
26160     try {
26161       result = Dali::TapGestureDetector::New();
26162     } CALL_CATCH_EXCEPTION(0);
26163   }
26164
26165   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
26166   return jresult;
26167 }
26168
26169
26170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_1(unsigned int jarg1) {
26171   void * jresult ;
26172   unsigned int arg1 ;
26173   Dali::TapGestureDetector result;
26174
26175   arg1 = (unsigned int)jarg1;
26176   {
26177     try {
26178       result = Dali::TapGestureDetector::New(arg1);
26179     } CALL_CATCH_EXCEPTION(0);
26180   }
26181
26182   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
26183   return jresult;
26184 }
26185
26186
26187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DownCast(void * jarg1) {
26188   void * jresult ;
26189   Dali::BaseHandle arg1 ;
26190   Dali::BaseHandle *argp1 ;
26191   Dali::TapGestureDetector result;
26192
26193   argp1 = (Dali::BaseHandle *)jarg1;
26194   if (!argp1) {
26195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26196     return 0;
26197   }
26198   arg1 = *argp1;
26199   {
26200     try {
26201       result = Dali::TapGestureDetector::DownCast(arg1);
26202     } CALL_CATCH_EXCEPTION(0);
26203   }
26204
26205   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
26206   return jresult;
26207 }
26208
26209
26210 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetector(void * jarg1) {
26211   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
26212
26213   arg1 = (Dali::TapGestureDetector *)jarg1;
26214   {
26215     try {
26216       delete arg1;
26217     } CALL_CATCH_EXCEPTION();
26218   }
26219
26220 }
26221
26222
26223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_1(void * jarg1) {
26224   void * jresult ;
26225   Dali::TapGestureDetector *arg1 = 0 ;
26226   Dali::TapGestureDetector *result = 0 ;
26227
26228   arg1 = (Dali::TapGestureDetector *)jarg1;
26229   if (!arg1) {
26230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
26231     return 0;
26232   }
26233   {
26234     try {
26235       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1);
26236     } CALL_CATCH_EXCEPTION(0);
26237   }
26238
26239   jresult = (void *)result;
26240   return jresult;
26241 }
26242
26243
26244 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_Assign(void * jarg1, void * jarg2) {
26245   void * jresult ;
26246   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
26247   Dali::TapGestureDetector *arg2 = 0 ;
26248   Dali::TapGestureDetector *result = 0 ;
26249
26250   arg1 = (Dali::TapGestureDetector *)jarg1;
26251   arg2 = (Dali::TapGestureDetector *)jarg2;
26252   if (!arg2) {
26253     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
26254     return 0;
26255   }
26256   {
26257     try {
26258       result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2);
26259     } CALL_CATCH_EXCEPTION(0);
26260   }
26261
26262   jresult = (void *)result;
26263   return jresult;
26264 }
26265
26266
26267 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) {
26268   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
26269   unsigned int arg2 ;
26270
26271   arg1 = (Dali::TapGestureDetector *)jarg1;
26272   arg2 = (unsigned int)jarg2;
26273   {
26274     try {
26275       (arg1)->SetMinimumTapsRequired(arg2);
26276     } CALL_CATCH_EXCEPTION();
26277   }
26278
26279 }
26280
26281
26282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) {
26283   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
26284   unsigned int arg2 ;
26285
26286   arg1 = (Dali::TapGestureDetector *)jarg1;
26287   arg2 = (unsigned int)jarg2;
26288   {
26289     try {
26290       (arg1)->SetMaximumTapsRequired(arg2);
26291     } CALL_CATCH_EXCEPTION();
26292   }
26293
26294 }
26295
26296
26297 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) {
26298   unsigned int jresult ;
26299   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
26300   unsigned int result;
26301
26302   arg1 = (Dali::TapGestureDetector *)jarg1;
26303   {
26304     try {
26305       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired();
26306     } CALL_CATCH_EXCEPTION(0);
26307   }
26308
26309   jresult = result;
26310   return jresult;
26311 }
26312
26313
26314 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMaximumTapsRequired(void * jarg1) {
26315   unsigned int jresult ;
26316   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
26317   unsigned int result;
26318
26319   arg1 = (Dali::TapGestureDetector *)jarg1;
26320   {
26321     try {
26322       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMaximumTapsRequired();
26323     } CALL_CATCH_EXCEPTION(0);
26324   }
26325
26326   jresult = result;
26327   return jresult;
26328 }
26329
26330
26331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DetectedSignal(void * jarg1) {
26332   void * jresult ;
26333   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
26334   Dali::TapGestureDetector::DetectedSignalType *result = 0 ;
26335
26336   arg1 = (Dali::TapGestureDetector *)jarg1;
26337   {
26338     try {
26339       result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
26340     } CALL_CATCH_EXCEPTION(0);
26341   }
26342
26343   jresult = (void *)result;
26344   return jresult;
26345 }
26346
26347
26348 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_0() {
26349   void * jresult ;
26350   Dali::TapGesture *result = 0 ;
26351
26352   {
26353     try {
26354       result = (Dali::TapGesture *)new Dali::TapGesture();
26355     } CALL_CATCH_EXCEPTION(0);
26356   }
26357
26358   jresult = (void *)result;
26359   return jresult;
26360 }
26361
26362
26363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_1(void * jarg1) {
26364   void * jresult ;
26365   Dali::TapGesture *arg1 = 0 ;
26366   Dali::TapGesture *result = 0 ;
26367
26368   arg1 = (Dali::TapGesture *)jarg1;
26369   if (!arg1) {
26370     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
26371     return 0;
26372   }
26373   {
26374     try {
26375       result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1);
26376     } CALL_CATCH_EXCEPTION(0);
26377   }
26378
26379   jresult = (void *)result;
26380   return jresult;
26381 }
26382
26383
26384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_Assign(void * jarg1, void * jarg2) {
26385   void * jresult ;
26386   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
26387   Dali::TapGesture *arg2 = 0 ;
26388   Dali::TapGesture *result = 0 ;
26389
26390   arg1 = (Dali::TapGesture *)jarg1;
26391   arg2 = (Dali::TapGesture *)jarg2;
26392   if (!arg2) {
26393     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
26394     return 0;
26395   }
26396   {
26397     try {
26398       result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2);
26399     } CALL_CATCH_EXCEPTION(0);
26400   }
26401
26402   jresult = (void *)result;
26403   return jresult;
26404 }
26405
26406
26407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGesture(void * jarg1) {
26408   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
26409
26410   arg1 = (Dali::TapGesture *)jarg1;
26411   {
26412     try {
26413       delete arg1;
26414     } CALL_CATCH_EXCEPTION();
26415   }
26416
26417 }
26418
26419
26420 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_get(void * jarg1) {
26421   unsigned int jresult ;
26422   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
26423   unsigned int result;
26424
26425   arg1 = (Dali::TapGesture *)jarg1;
26426   result = (unsigned int) ((arg1)->GetNumberOfTaps());
26427   jresult = result;
26428   return jresult;
26429 }
26430
26431 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_get(void * jarg1) {
26432   unsigned int jresult ;
26433   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
26434   unsigned int result;
26435
26436   arg1 = (Dali::TapGesture *)jarg1;
26437   result = (unsigned int) ((arg1)->GetNumberOfTouches());
26438   jresult = result;
26439   return jresult;
26440 }
26441
26442
26443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_get(void * jarg1) {
26444   void * jresult ;
26445   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
26446   Dali::Vector2 result;
26447
26448   arg1 = (Dali::TapGesture *)jarg1;
26449   {
26450     try {
26451       result = ((Dali::TapGesture const *)arg1)->GetScreenPoint();
26452     } catch (std::out_of_range& e) {
26453       {
26454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26455       };
26456     } catch (std::exception& e) {
26457       {
26458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26459       };
26460     } catch (Dali::DaliException e) {
26461       {
26462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26463       };
26464     } catch (...) {
26465       {
26466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26467       };
26468     }
26469   }
26470   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
26471   return jresult;
26472 }
26473
26474
26475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_get(void * jarg1) {
26476   void * jresult ;
26477   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
26478   Dali::Vector2 result;
26479
26480   arg1 = (Dali::TapGesture *)jarg1;
26481   {
26482     try {
26483       result = ((Dali::TapGesture const *)arg1)->GetLocalPoint();
26484     } catch (std::out_of_range& e) {
26485       {
26486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26487       };
26488     } catch (std::exception& e) {
26489       {
26490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26491       };
26492     } catch (Dali::DaliException e) {
26493       {
26494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26495       };
26496     } catch (...) {
26497       {
26498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26499       };
26500     }
26501   }
26502   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
26503   return jresult;
26504 }
26505
26506
26507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_0() {
26508   void * jresult ;
26509   Dali::AlphaFunction *result = 0 ;
26510
26511   {
26512     try {
26513       result = (Dali::AlphaFunction *)new Dali::AlphaFunction();
26514     } CALL_CATCH_EXCEPTION(0);
26515   }
26516
26517   jresult = (void *)result;
26518   return jresult;
26519 }
26520
26521
26522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_1(int jarg1) {
26523   void * jresult ;
26524   Dali::AlphaFunction::BuiltinFunction arg1 ;
26525   Dali::AlphaFunction *result = 0 ;
26526
26527   arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1;
26528   {
26529     try {
26530       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
26531     } CALL_CATCH_EXCEPTION(0);
26532   }
26533
26534   jresult = (void *)result;
26535   return jresult;
26536 }
26537
26538
26539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_2(void * jarg1) {
26540   void * jresult ;
26541   Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ;
26542   Dali::AlphaFunction *result = 0 ;
26543
26544   arg1 = (Dali::AlphaFunctionPrototype)jarg1;
26545   {
26546     try {
26547       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
26548     } CALL_CATCH_EXCEPTION(0);
26549   }
26550
26551   jresult = (void *)result;
26552   return jresult;
26553 }
26554
26555
26556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_3(void * jarg1, void * jarg2) {
26557   void * jresult ;
26558   Dali::Vector2 *arg1 = 0 ;
26559   Dali::Vector2 *arg2 = 0 ;
26560   Dali::AlphaFunction *result = 0 ;
26561
26562   arg1 = (Dali::Vector2 *)jarg1;
26563   if (!arg1) {
26564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
26565     return 0;
26566   }
26567   arg2 = (Dali::Vector2 *)jarg2;
26568   if (!arg2) {
26569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
26570     return 0;
26571   }
26572   {
26573     try {
26574       result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
26575     } CALL_CATCH_EXCEPTION(0);
26576   }
26577
26578   jresult = (void *)result;
26579   return jresult;
26580 }
26581
26582
26583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBezierControlPoints(void * jarg1) {
26584   void * jresult ;
26585   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
26586   Dali::Vector4 result;
26587
26588   arg1 = (Dali::AlphaFunction *)jarg1;
26589   {
26590     try {
26591       result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints();
26592     } CALL_CATCH_EXCEPTION(0);
26593   }
26594
26595   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
26596   return jresult;
26597 }
26598
26599
26600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetCustomFunction(void * jarg1) {
26601   void * jresult ;
26602   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
26603   Dali::AlphaFunctionPrototype result;
26604
26605   arg1 = (Dali::AlphaFunction *)jarg1;
26606   {
26607     try {
26608       result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction();
26609     } CALL_CATCH_EXCEPTION(0);
26610   }
26611
26612   jresult = (void *)result;
26613   return jresult;
26614 }
26615
26616
26617 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBuiltinFunction(void * jarg1) {
26618   int jresult ;
26619   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
26620   Dali::AlphaFunction::BuiltinFunction result;
26621
26622   arg1 = (Dali::AlphaFunction *)jarg1;
26623   {
26624     try {
26625       result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction();
26626     } CALL_CATCH_EXCEPTION(0);
26627   }
26628
26629   jresult = (int)result;
26630   return jresult;
26631 }
26632
26633
26634 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetMode(void * jarg1) {
26635   int jresult ;
26636   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
26637   Dali::AlphaFunction::Mode result;
26638
26639   arg1 = (Dali::AlphaFunction *)jarg1;
26640   {
26641     try {
26642       result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode();
26643     } CALL_CATCH_EXCEPTION(0);
26644   }
26645
26646   jresult = (int)result;
26647   return jresult;
26648 }
26649
26650
26651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AlphaFunction(void * jarg1) {
26652   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
26653
26654   arg1 = (Dali::AlphaFunction *)jarg1;
26655   {
26656     try {
26657       delete arg1;
26658     } CALL_CATCH_EXCEPTION();
26659   }
26660
26661 }
26662
26663
26664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_New() {
26665   void * jresult ;
26666   Dali::KeyFrames result;
26667
26668   {
26669     try {
26670       result = Dali::KeyFrames::New();
26671     } CALL_CATCH_EXCEPTION(0);
26672   }
26673
26674   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
26675   return jresult;
26676 }
26677
26678
26679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_DownCast(void * jarg1) {
26680   void * jresult ;
26681   Dali::BaseHandle arg1 ;
26682   Dali::BaseHandle *argp1 ;
26683   Dali::KeyFrames result;
26684
26685   argp1 = (Dali::BaseHandle *)jarg1;
26686   if (!argp1) {
26687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26688     return 0;
26689   }
26690   arg1 = *argp1;
26691   {
26692     try {
26693       result = Dali::KeyFrames::DownCast(arg1);
26694     } CALL_CATCH_EXCEPTION(0);
26695   }
26696
26697   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
26698   return jresult;
26699 }
26700
26701
26702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_0() {
26703   void * jresult ;
26704   Dali::KeyFrames *result = 0 ;
26705
26706   {
26707     try {
26708       result = (Dali::KeyFrames *)new Dali::KeyFrames();
26709     } CALL_CATCH_EXCEPTION(0);
26710   }
26711
26712   jresult = (void *)result;
26713   return jresult;
26714 }
26715
26716
26717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyFrames(void * jarg1) {
26718   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
26719
26720   arg1 = (Dali::KeyFrames *)jarg1;
26721   {
26722     try {
26723       delete arg1;
26724     } CALL_CATCH_EXCEPTION();
26725   }
26726
26727 }
26728
26729
26730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_1(void * jarg1) {
26731   void * jresult ;
26732   Dali::KeyFrames *arg1 = 0 ;
26733   Dali::KeyFrames *result = 0 ;
26734
26735   arg1 = (Dali::KeyFrames *)jarg1;
26736   if (!arg1) {
26737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
26738     return 0;
26739   }
26740   {
26741     try {
26742       result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1);
26743     } CALL_CATCH_EXCEPTION(0);
26744   }
26745
26746   jresult = (void *)result;
26747   return jresult;
26748 }
26749
26750
26751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_Assign(void * jarg1, void * jarg2) {
26752   void * jresult ;
26753   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
26754   Dali::KeyFrames *arg2 = 0 ;
26755   Dali::KeyFrames *result = 0 ;
26756
26757   arg1 = (Dali::KeyFrames *)jarg1;
26758   arg2 = (Dali::KeyFrames *)jarg2;
26759   if (!arg2) {
26760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
26761     return 0;
26762   }
26763   {
26764     try {
26765       result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2);
26766     } CALL_CATCH_EXCEPTION(0);
26767   }
26768
26769   jresult = (void *)result;
26770   return jresult;
26771 }
26772
26773
26774 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_KeyFrames_GetType(void * jarg1) {
26775   int jresult ;
26776   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
26777   Dali::Property::Type result;
26778
26779   arg1 = (Dali::KeyFrames *)jarg1;
26780   {
26781     try {
26782       result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType();
26783     } CALL_CATCH_EXCEPTION(0);
26784   }
26785
26786   jresult = (int)result;
26787   return jresult;
26788 }
26789
26790
26791 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) {
26792   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
26793   float arg2 ;
26794   Dali::Property::Value arg3 ;
26795   Dali::Property::Value *argp3 ;
26796
26797   arg1 = (Dali::KeyFrames *)jarg1;
26798   arg2 = (float)jarg2;
26799   argp3 = (Dali::Property::Value *)jarg3;
26800   if (!argp3) {
26801     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
26802     return ;
26803   }
26804   arg3 = *argp3;
26805   {
26806     try {
26807       (arg1)->Add(arg2,arg3);
26808     } CALL_CATCH_EXCEPTION();
26809   }
26810
26811 }
26812
26813
26814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
26815   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
26816   float arg2 ;
26817   Dali::Property::Value arg3 ;
26818   Dali::AlphaFunction arg4 ;
26819   Dali::Property::Value *argp3 ;
26820   Dali::AlphaFunction *argp4 ;
26821
26822   arg1 = (Dali::KeyFrames *)jarg1;
26823   arg2 = (float)jarg2;
26824   argp3 = (Dali::Property::Value *)jarg3;
26825   if (!argp3) {
26826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
26827     return ;
26828   }
26829   arg3 = *argp3;
26830   argp4 = (Dali::AlphaFunction *)jarg4;
26831   if (!argp4) {
26832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
26833     return ;
26834   }
26835   arg4 = *argp4;
26836   {
26837     try {
26838       (arg1)->Add(arg2,arg3,arg4);
26839     } CALL_CATCH_EXCEPTION();
26840   }
26841
26842 }
26843
26844
26845 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_POINTS_get() {
26846   int jresult ;
26847   int result;
26848
26849   result = (int)Dali::Path::Property::POINTS;
26850   jresult = (int)result;
26851   return jresult;
26852 }
26853
26854
26855 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_CONTROL_POINTS_get() {
26856   int jresult ;
26857   int result;
26858
26859   result = (int)Dali::Path::Property::CONTROL_POINTS;
26860   jresult = (int)result;
26861   return jresult;
26862 }
26863
26864
26865 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path_Property() {
26866   void * jresult ;
26867   Dali::Path::Property *result = 0 ;
26868
26869   {
26870     try {
26871       result = (Dali::Path::Property *)new Dali::Path::Property();
26872     } CALL_CATCH_EXCEPTION(0);
26873   }
26874
26875   jresult = (void *)result;
26876   return jresult;
26877 }
26878
26879
26880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path_Property(void * jarg1) {
26881   Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ;
26882
26883   arg1 = (Dali::Path::Property *)jarg1;
26884   {
26885     try {
26886       delete arg1;
26887     } CALL_CATCH_EXCEPTION();
26888   }
26889
26890 }
26891
26892
26893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_New() {
26894   void * jresult ;
26895   Dali::Path result;
26896
26897   {
26898     try {
26899       result = Dali::Path::New();
26900     } CALL_CATCH_EXCEPTION(0);
26901   }
26902
26903   jresult = new Dali::Path((const Dali::Path &)result);
26904   return jresult;
26905 }
26906
26907
26908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_DownCast(void * jarg1) {
26909   void * jresult ;
26910   Dali::BaseHandle arg1 ;
26911   Dali::BaseHandle *argp1 ;
26912   Dali::Path result;
26913
26914   argp1 = (Dali::BaseHandle *)jarg1;
26915   if (!argp1) {
26916     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26917     return 0;
26918   }
26919   arg1 = *argp1;
26920   {
26921     try {
26922       result = Dali::Path::DownCast(arg1);
26923     } CALL_CATCH_EXCEPTION(0);
26924   }
26925
26926   jresult = new Dali::Path((const Dali::Path &)result);
26927   return jresult;
26928 }
26929
26930
26931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_0() {
26932   void * jresult ;
26933   Dali::Path *result = 0 ;
26934
26935   {
26936     try {
26937       result = (Dali::Path *)new Dali::Path();
26938     } CALL_CATCH_EXCEPTION(0);
26939   }
26940
26941   jresult = (void *)result;
26942   return jresult;
26943 }
26944
26945
26946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path(void * jarg1) {
26947   Dali::Path *arg1 = (Dali::Path *) 0 ;
26948
26949   arg1 = (Dali::Path *)jarg1;
26950   {
26951     try {
26952       delete arg1;
26953     } CALL_CATCH_EXCEPTION();
26954   }
26955
26956 }
26957
26958
26959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_1(void * jarg1) {
26960   void * jresult ;
26961   Dali::Path *arg1 = 0 ;
26962   Dali::Path *result = 0 ;
26963
26964   arg1 = (Dali::Path *)jarg1;
26965   if (!arg1) {
26966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
26967     return 0;
26968   }
26969   {
26970     try {
26971       result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1);
26972     } CALL_CATCH_EXCEPTION(0);
26973   }
26974
26975   jresult = (void *)result;
26976   return jresult;
26977 }
26978
26979
26980 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_Assign(void * jarg1, void * jarg2) {
26981   void * jresult ;
26982   Dali::Path *arg1 = (Dali::Path *) 0 ;
26983   Dali::Path *arg2 = 0 ;
26984   Dali::Path *result = 0 ;
26985
26986   arg1 = (Dali::Path *)jarg1;
26987   arg2 = (Dali::Path *)jarg2;
26988   if (!arg2) {
26989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
26990     return 0;
26991   }
26992   {
26993     try {
26994       result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2);
26995     } CALL_CATCH_EXCEPTION(0);
26996   }
26997
26998   jresult = (void *)result;
26999   return jresult;
27000 }
27001
27002
27003 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddPoint(void * jarg1, void * jarg2) {
27004   Dali::Path *arg1 = (Dali::Path *) 0 ;
27005   Dali::Vector3 *arg2 = 0 ;
27006
27007   arg1 = (Dali::Path *)jarg1;
27008   arg2 = (Dali::Vector3 *)jarg2;
27009   if (!arg2) {
27010     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
27011     return ;
27012   }
27013   {
27014     try {
27015       (arg1)->AddPoint((Dali::Vector3 const &)*arg2);
27016     } CALL_CATCH_EXCEPTION();
27017   }
27018
27019 }
27020
27021
27022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddControlPoint(void * jarg1, void * jarg2) {
27023   Dali::Path *arg1 = (Dali::Path *) 0 ;
27024   Dali::Vector3 *arg2 = 0 ;
27025
27026   arg1 = (Dali::Path *)jarg1;
27027   arg2 = (Dali::Vector3 *)jarg2;
27028   if (!arg2) {
27029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
27030     return ;
27031   }
27032   {
27033     try {
27034       (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2);
27035     } CALL_CATCH_EXCEPTION();
27036   }
27037
27038 }
27039
27040
27041 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_GenerateControlPoints(void * jarg1, float jarg2) {
27042   Dali::Path *arg1 = (Dali::Path *) 0 ;
27043   float arg2 ;
27044
27045   arg1 = (Dali::Path *)jarg1;
27046   arg2 = (float)jarg2;
27047   {
27048     try {
27049       (arg1)->GenerateControlPoints(arg2);
27050     } CALL_CATCH_EXCEPTION();
27051   }
27052
27053 }
27054
27055
27056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
27057   Dali::Path *arg1 = (Dali::Path *) 0 ;
27058   float arg2 ;
27059   Dali::Vector3 *arg3 = 0 ;
27060   Dali::Vector3 *arg4 = 0 ;
27061
27062   arg1 = (Dali::Path *)jarg1;
27063   arg2 = (float)jarg2;
27064   arg3 = (Dali::Vector3 *)jarg3;
27065   if (!arg3) {
27066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
27067     return ;
27068   }
27069   arg4 = (Dali::Vector3 *)jarg4;
27070   if (!arg4) {
27071     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
27072     return ;
27073   }
27074   {
27075     try {
27076       ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4);
27077     } CALL_CATCH_EXCEPTION();
27078   }
27079
27080 }
27081
27082
27083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetPoint(void * jarg1, unsigned long jarg2) {
27084   void * jresult ;
27085   Dali::Path *arg1 = (Dali::Path *) 0 ;
27086   size_t arg2 ;
27087   Dali::Vector3 *result = 0 ;
27088
27089   arg1 = (Dali::Path *)jarg1;
27090   arg2 = (size_t)jarg2;
27091   {
27092     try {
27093       result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2);
27094     } CALL_CATCH_EXCEPTION(0);
27095   }
27096
27097   jresult = (void *)result;
27098   return jresult;
27099 }
27100
27101
27102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetControlPoint(void * jarg1, unsigned long jarg2) {
27103   void * jresult ;
27104   Dali::Path *arg1 = (Dali::Path *) 0 ;
27105   size_t arg2 ;
27106   Dali::Vector3 *result = 0 ;
27107
27108   arg1 = (Dali::Path *)jarg1;
27109   arg2 = (size_t)jarg2;
27110   {
27111     try {
27112       result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2);
27113     } CALL_CATCH_EXCEPTION(0);
27114   }
27115
27116   jresult = (void *)result;
27117   return jresult;
27118 }
27119
27120
27121 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Path_GetPointCount(void * jarg1) {
27122   unsigned long jresult ;
27123   Dali::Path *arg1 = (Dali::Path *) 0 ;
27124   size_t result;
27125
27126   arg1 = (Dali::Path *)jarg1;
27127   {
27128     try {
27129       result = ((Dali::Path const *)arg1)->GetPointCount();
27130     } CALL_CATCH_EXCEPTION(0);
27131   }
27132
27133   jresult = (unsigned long)result;
27134   return jresult;
27135 }
27136
27137
27138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_0(float jarg1) {
27139   void * jresult ;
27140   float arg1 ;
27141   Dali::TimePeriod *result = 0 ;
27142
27143   arg1 = (float)jarg1;
27144   {
27145     try {
27146       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1);
27147     } CALL_CATCH_EXCEPTION(0);
27148   }
27149
27150   jresult = (void *)result;
27151   return jresult;
27152 }
27153
27154
27155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_1(float jarg1, float jarg2) {
27156   void * jresult ;
27157   float arg1 ;
27158   float arg2 ;
27159   Dali::TimePeriod *result = 0 ;
27160
27161   arg1 = (float)jarg1;
27162   arg2 = (float)jarg2;
27163   {
27164     try {
27165       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2);
27166     } CALL_CATCH_EXCEPTION(0);
27167   }
27168
27169   jresult = (void *)result;
27170   return jresult;
27171 }
27172
27173
27174 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimePeriod(void * jarg1) {
27175   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
27176
27177   arg1 = (Dali::TimePeriod *)jarg1;
27178   {
27179     try {
27180       delete arg1;
27181     } CALL_CATCH_EXCEPTION();
27182   }
27183
27184 }
27185
27186
27187 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) {
27188   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
27189   float arg2 ;
27190
27191   arg1 = (Dali::TimePeriod *)jarg1;
27192   arg2 = (float)jarg2;
27193   if (arg1) (arg1)->delaySeconds = arg2;
27194 }
27195
27196
27197 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_get(void * jarg1) {
27198   float jresult ;
27199   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
27200   float result;
27201
27202   arg1 = (Dali::TimePeriod *)jarg1;
27203   result = (float) ((arg1)->delaySeconds);
27204   jresult = result;
27205   return jresult;
27206 }
27207
27208
27209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) {
27210   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
27211   float arg2 ;
27212
27213   arg1 = (Dali::TimePeriod *)jarg1;
27214   arg2 = (float)jarg2;
27215   if (arg1) (arg1)->durationSeconds = arg2;
27216 }
27217
27218
27219 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_get(void * jarg1) {
27220   float jresult ;
27221   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
27222   float result;
27223
27224   arg1 = (Dali::TimePeriod *)jarg1;
27225   result = (float) ((arg1)->durationSeconds);
27226   jresult = result;
27227   return jresult;
27228 }
27229
27230 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_VALUE_get() {
27231   int jresult ;
27232   int result;
27233
27234   result = (int)Dali::LinearConstrainer::Property::VALUE;
27235   jresult = (int)result;
27236   return jresult;
27237 }
27238
27239
27240 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_PROGRESS_get() {
27241   int jresult ;
27242   int result;
27243
27244   result = (int)Dali::LinearConstrainer::Property::PROGRESS;
27245   jresult = (int)result;
27246   return jresult;
27247 }
27248
27249
27250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer_Property() {
27251   void * jresult ;
27252   Dali::LinearConstrainer::Property *result = 0 ;
27253
27254   {
27255     try {
27256       result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property();
27257     } CALL_CATCH_EXCEPTION(0);
27258   }
27259
27260   jresult = (void *)result;
27261   return jresult;
27262 }
27263
27264
27265 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer_Property(void * jarg1) {
27266   Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ;
27267
27268   arg1 = (Dali::LinearConstrainer::Property *)jarg1;
27269   {
27270     try {
27271       delete arg1;
27272     } CALL_CATCH_EXCEPTION();
27273   }
27274
27275 }
27276
27277
27278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_New() {
27279   void * jresult ;
27280   Dali::LinearConstrainer result;
27281
27282   {
27283     try {
27284       result = Dali::LinearConstrainer::New();
27285     } CALL_CATCH_EXCEPTION(0);
27286   }
27287
27288   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
27289   return jresult;
27290 }
27291
27292
27293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_DownCast(void * jarg1) {
27294   void * jresult ;
27295   Dali::BaseHandle arg1 ;
27296   Dali::BaseHandle *argp1 ;
27297   Dali::LinearConstrainer result;
27298
27299   argp1 = (Dali::BaseHandle *)jarg1;
27300   if (!argp1) {
27301     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27302     return 0;
27303   }
27304   arg1 = *argp1;
27305   {
27306     try {
27307       result = Dali::LinearConstrainer::DownCast(arg1);
27308     } CALL_CATCH_EXCEPTION(0);
27309   }
27310
27311   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
27312   return jresult;
27313 }
27314
27315
27316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_0() {
27317   void * jresult ;
27318   Dali::LinearConstrainer *result = 0 ;
27319
27320   {
27321     try {
27322       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer();
27323     } CALL_CATCH_EXCEPTION(0);
27324   }
27325
27326   jresult = (void *)result;
27327   return jresult;
27328 }
27329
27330
27331 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer(void * jarg1) {
27332   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
27333
27334   arg1 = (Dali::LinearConstrainer *)jarg1;
27335   {
27336     try {
27337       delete arg1;
27338     } CALL_CATCH_EXCEPTION();
27339   }
27340
27341 }
27342
27343
27344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_1(void * jarg1) {
27345   void * jresult ;
27346   Dali::LinearConstrainer *arg1 = 0 ;
27347   Dali::LinearConstrainer *result = 0 ;
27348
27349   arg1 = (Dali::LinearConstrainer *)jarg1;
27350   if (!arg1) {
27351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
27352     return 0;
27353   }
27354   {
27355     try {
27356       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1);
27357     } CALL_CATCH_EXCEPTION(0);
27358   }
27359
27360   jresult = (void *)result;
27361   return jresult;
27362 }
27363
27364
27365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_Assign(void * jarg1, void * jarg2) {
27366   void * jresult ;
27367   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
27368   Dali::LinearConstrainer *arg2 = 0 ;
27369   Dali::LinearConstrainer *result = 0 ;
27370
27371   arg1 = (Dali::LinearConstrainer *)jarg1;
27372   arg2 = (Dali::LinearConstrainer *)jarg2;
27373   if (!arg2) {
27374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
27375     return 0;
27376   }
27377   {
27378     try {
27379       result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2);
27380     } CALL_CATCH_EXCEPTION(0);
27381   }
27382
27383   jresult = (void *)result;
27384   return jresult;
27385 }
27386
27387
27388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
27389   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
27390   SwigValueWrapper< Dali::Property > arg2 ;
27391   SwigValueWrapper< Dali::Property > arg3 ;
27392   Dali::Vector2 *arg4 = 0 ;
27393   Dali::Vector2 *arg5 = 0 ;
27394   Dali::Property *argp2 ;
27395   Dali::Property *argp3 ;
27396
27397   arg1 = (Dali::LinearConstrainer *)jarg1;
27398   argp2 = (Dali::Property *)jarg2;
27399   if (!argp2) {
27400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
27401     return ;
27402   }
27403   arg2 = *argp2;
27404   argp3 = (Dali::Property *)jarg3;
27405   if (!argp3) {
27406     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
27407     return ;
27408   }
27409   arg3 = *argp3;
27410   arg4 = (Dali::Vector2 *)jarg4;
27411   if (!arg4) {
27412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
27413     return ;
27414   }
27415   arg5 = (Dali::Vector2 *)jarg5;
27416   if (!arg5) {
27417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
27418     return ;
27419   }
27420   {
27421     try {
27422       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
27423     } CALL_CATCH_EXCEPTION();
27424   }
27425
27426 }
27427
27428
27429 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
27430   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
27431   SwigValueWrapper< Dali::Property > arg2 ;
27432   SwigValueWrapper< Dali::Property > arg3 ;
27433   Dali::Vector2 *arg4 = 0 ;
27434   Dali::Property *argp2 ;
27435   Dali::Property *argp3 ;
27436
27437   arg1 = (Dali::LinearConstrainer *)jarg1;
27438   argp2 = (Dali::Property *)jarg2;
27439   if (!argp2) {
27440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
27441     return ;
27442   }
27443   arg2 = *argp2;
27444   argp3 = (Dali::Property *)jarg3;
27445   if (!argp3) {
27446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
27447     return ;
27448   }
27449   arg3 = *argp3;
27450   arg4 = (Dali::Vector2 *)jarg4;
27451   if (!arg4) {
27452     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
27453     return ;
27454   }
27455   {
27456     try {
27457       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
27458     } CALL_CATCH_EXCEPTION();
27459   }
27460
27461 }
27462
27463
27464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Remove(void * jarg1, void * jarg2) {
27465   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
27466   Dali::Handle *arg2 = 0 ;
27467
27468   arg1 = (Dali::LinearConstrainer *)jarg1;
27469   arg2 = (Dali::Handle *)jarg2;
27470   if (!arg2) {
27471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
27472     return ;
27473   }
27474   {
27475     try {
27476       (arg1)->Remove(*arg2);
27477     } CALL_CATCH_EXCEPTION();
27478   }
27479
27480 }
27481
27482
27483 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_FORWARD_get() {
27484   int jresult ;
27485   int result;
27486
27487   result = (int)Dali::PathConstrainer::Property::FORWARD;
27488   jresult = (int)result;
27489   return jresult;
27490 }
27491
27492
27493 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_POINTS_get() {
27494   int jresult ;
27495   int result;
27496
27497   result = (int)Dali::PathConstrainer::Property::POINTS;
27498   jresult = (int)result;
27499   return jresult;
27500 }
27501
27502
27503 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_CONTROL_POINTS_get() {
27504   int jresult ;
27505   int result;
27506
27507   result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS;
27508   jresult = (int)result;
27509   return jresult;
27510 }
27511
27512
27513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer_Property() {
27514   void * jresult ;
27515   Dali::PathConstrainer::Property *result = 0 ;
27516
27517   {
27518     try {
27519       result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property();
27520     } CALL_CATCH_EXCEPTION(0);
27521   }
27522
27523   jresult = (void *)result;
27524   return jresult;
27525 }
27526
27527
27528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer_Property(void * jarg1) {
27529   Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ;
27530
27531   arg1 = (Dali::PathConstrainer::Property *)jarg1;
27532   {
27533     try {
27534       delete arg1;
27535     } CALL_CATCH_EXCEPTION();
27536   }
27537
27538 }
27539
27540
27541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_New() {
27542   void * jresult ;
27543   Dali::PathConstrainer result;
27544
27545   {
27546     try {
27547       result = Dali::PathConstrainer::New();
27548     } CALL_CATCH_EXCEPTION(0);
27549   }
27550
27551   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
27552   return jresult;
27553 }
27554
27555
27556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_DownCast(void * jarg1) {
27557   void * jresult ;
27558   Dali::BaseHandle arg1 ;
27559   Dali::BaseHandle *argp1 ;
27560   Dali::PathConstrainer result;
27561
27562   argp1 = (Dali::BaseHandle *)jarg1;
27563   if (!argp1) {
27564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27565     return 0;
27566   }
27567   arg1 = *argp1;
27568   {
27569     try {
27570       result = Dali::PathConstrainer::DownCast(arg1);
27571     } CALL_CATCH_EXCEPTION(0);
27572   }
27573
27574   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
27575   return jresult;
27576 }
27577
27578
27579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_0() {
27580   void * jresult ;
27581   Dali::PathConstrainer *result = 0 ;
27582
27583   {
27584     try {
27585       result = (Dali::PathConstrainer *)new Dali::PathConstrainer();
27586     } CALL_CATCH_EXCEPTION(0);
27587   }
27588
27589   jresult = (void *)result;
27590   return jresult;
27591 }
27592
27593
27594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer(void * jarg1) {
27595   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
27596
27597   arg1 = (Dali::PathConstrainer *)jarg1;
27598   {
27599     try {
27600       delete arg1;
27601     } CALL_CATCH_EXCEPTION();
27602   }
27603
27604 }
27605
27606
27607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_1(void * jarg1) {
27608   void * jresult ;
27609   Dali::PathConstrainer *arg1 = 0 ;
27610   Dali::PathConstrainer *result = 0 ;
27611
27612   arg1 = (Dali::PathConstrainer *)jarg1;
27613   if (!arg1) {
27614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
27615     return 0;
27616   }
27617   {
27618     try {
27619       result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1);
27620     } CALL_CATCH_EXCEPTION(0);
27621   }
27622
27623   jresult = (void *)result;
27624   return jresult;
27625 }
27626
27627
27628 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_Assign(void * jarg1, void * jarg2) {
27629   void * jresult ;
27630   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
27631   Dali::PathConstrainer *arg2 = 0 ;
27632   Dali::PathConstrainer *result = 0 ;
27633
27634   arg1 = (Dali::PathConstrainer *)jarg1;
27635   arg2 = (Dali::PathConstrainer *)jarg2;
27636   if (!arg2) {
27637     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
27638     return 0;
27639   }
27640   {
27641     try {
27642       result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2);
27643     } CALL_CATCH_EXCEPTION(0);
27644   }
27645
27646   jresult = (void *)result;
27647   return jresult;
27648 }
27649
27650
27651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
27652   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
27653   SwigValueWrapper< Dali::Property > arg2 ;
27654   SwigValueWrapper< Dali::Property > arg3 ;
27655   Dali::Vector2 *arg4 = 0 ;
27656   Dali::Vector2 *arg5 = 0 ;
27657   Dali::Property *argp2 ;
27658   Dali::Property *argp3 ;
27659
27660   arg1 = (Dali::PathConstrainer *)jarg1;
27661   argp2 = (Dali::Property *)jarg2;
27662   if (!argp2) {
27663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
27664     return ;
27665   }
27666   arg2 = *argp2;
27667   argp3 = (Dali::Property *)jarg3;
27668   if (!argp3) {
27669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
27670     return ;
27671   }
27672   arg3 = *argp3;
27673   arg4 = (Dali::Vector2 *)jarg4;
27674   if (!arg4) {
27675     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
27676     return ;
27677   }
27678   arg5 = (Dali::Vector2 *)jarg5;
27679   if (!arg5) {
27680     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
27681     return ;
27682   }
27683   {
27684     try {
27685       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
27686     } CALL_CATCH_EXCEPTION();
27687   }
27688
27689 }
27690
27691
27692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
27693   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
27694   SwigValueWrapper< Dali::Property > arg2 ;
27695   SwigValueWrapper< Dali::Property > arg3 ;
27696   Dali::Vector2 *arg4 = 0 ;
27697   Dali::Property *argp2 ;
27698   Dali::Property *argp3 ;
27699
27700   arg1 = (Dali::PathConstrainer *)jarg1;
27701   argp2 = (Dali::Property *)jarg2;
27702   if (!argp2) {
27703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
27704     return ;
27705   }
27706   arg2 = *argp2;
27707   argp3 = (Dali::Property *)jarg3;
27708   if (!argp3) {
27709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
27710     return ;
27711   }
27712   arg3 = *argp3;
27713   arg4 = (Dali::Vector2 *)jarg4;
27714   if (!arg4) {
27715     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
27716     return ;
27717   }
27718   {
27719     try {
27720       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
27721     } CALL_CATCH_EXCEPTION();
27722   }
27723
27724 }
27725
27726
27727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Remove(void * jarg1, void * jarg2) {
27728   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
27729   Dali::Handle *arg2 = 0 ;
27730
27731   arg1 = (Dali::PathConstrainer *)jarg1;
27732   arg2 = (Dali::Handle *)jarg2;
27733   if (!arg2) {
27734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
27735     return ;
27736   }
27737   {
27738     try {
27739       (arg1)->Remove(*arg2);
27740     } CALL_CATCH_EXCEPTION();
27741   }
27742
27743 }
27744
27745
27746 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FittingModeDefault_get() {
27747   int jresult ;
27748   Dali::FittingMode::Type result;
27749
27750   result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT;
27751   jresult = (int)result;
27752   return jresult;
27753 }
27754
27755
27756 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DEFAULT_get() {
27757   int jresult ;
27758   Dali::SamplingMode::Type result;
27759
27760   result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT;
27761   jresult = (int)result;
27762   return jresult;
27763 }
27764
27765
27766 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_CreateResource(void * jarg1) {
27767   unsigned int jresult ;
27768   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
27769   bool result;
27770
27771   arg1 = (Dali::NativeImageInterface *)jarg1;
27772   {
27773     try {
27774       result = (bool)(arg1)->CreateResource();
27775     } CALL_CATCH_EXCEPTION(0);
27776   }
27777
27778   jresult = result;
27779   return jresult;
27780 }
27781
27782
27783 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_DestroyResource(void * jarg1) {
27784   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
27785
27786   arg1 = (Dali::NativeImageInterface *)jarg1;
27787   {
27788     try {
27789       (arg1)->DestroyResource();
27790     } CALL_CATCH_EXCEPTION();
27791   }
27792
27793 }
27794
27795
27796 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_TargetTexture(void * jarg1) {
27797   unsigned int jresult ;
27798   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
27799   unsigned int result;
27800
27801   arg1 = (Dali::NativeImageInterface *)jarg1;
27802   {
27803     try {
27804       result = (unsigned int)(arg1)->TargetTexture();
27805     } CALL_CATCH_EXCEPTION(0);
27806   }
27807
27808   jresult = result;
27809   return jresult;
27810 }
27811
27812
27813 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_PrepareTexture(void * jarg1) {
27814   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
27815
27816   arg1 = (Dali::NativeImageInterface *)jarg1;
27817   {
27818     try {
27819       (arg1)->PrepareTexture();
27820     } CALL_CATCH_EXCEPTION();
27821   }
27822
27823 }
27824
27825
27826 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetWidth(void * jarg1) {
27827   unsigned int jresult ;
27828   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
27829   unsigned int result;
27830
27831   arg1 = (Dali::NativeImageInterface *)jarg1;
27832   {
27833     try {
27834       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth();
27835     } CALL_CATCH_EXCEPTION(0);
27836   }
27837
27838   jresult = result;
27839   return jresult;
27840 }
27841
27842
27843 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetHeight(void * jarg1) {
27844   unsigned int jresult ;
27845   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
27846   unsigned int result;
27847
27848   arg1 = (Dali::NativeImageInterface *)jarg1;
27849   {
27850     try {
27851       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetHeight();
27852     } CALL_CATCH_EXCEPTION(0);
27853   }
27854
27855   jresult = result;
27856   return jresult;
27857 }
27858
27859
27860 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_RequiresBlending(void * jarg1) {
27861   unsigned int jresult ;
27862   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
27863   bool result;
27864
27865   arg1 = (Dali::NativeImageInterface *)jarg1;
27866   {
27867     try {
27868       result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending();
27869     } CALL_CATCH_EXCEPTION(0);
27870   }
27871
27872   jresult = result;
27873   return jresult;
27874 }
27875
27876 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TYPE_get() {
27877   int jresult ;
27878   int result;
27879
27880   result = (int)Dali::CameraActor::Property::TYPE;
27881   jresult = (int)result;
27882   return jresult;
27883 }
27884
27885
27886 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MODE_get() {
27887   int jresult ;
27888   int result;
27889
27890   result = (int)Dali::CameraActor::Property::PROJECTION_MODE;
27891   jresult = (int)result;
27892   return jresult;
27893 }
27894
27895
27896 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FIELD_OF_VIEW_get() {
27897   int jresult ;
27898   int result;
27899
27900   result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW;
27901   jresult = (int)result;
27902   return jresult;
27903 }
27904
27905
27906 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ASPECT_RATIO_get() {
27907   int jresult ;
27908   int result;
27909
27910   result = (int)Dali::CameraActor::Property::ASPECT_RATIO;
27911   jresult = (int)result;
27912   return jresult;
27913 }
27914
27915
27916 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_NEAR_PLANE_DISTANCE_get() {
27917   int jresult ;
27918   int result;
27919
27920   result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE;
27921   jresult = (int)result;
27922   return jresult;
27923 }
27924
27925
27926 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FAR_PLANE_DISTANCE_get() {
27927   int jresult ;
27928   int result;
27929
27930   result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE;
27931   jresult = (int)result;
27932   return jresult;
27933 }
27934
27935
27936 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_LEFT_PLANE_DISTANCE_get() {
27937   int jresult ;
27938   int result;
27939
27940   result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE;
27941   jresult = (int)result;
27942   return jresult;
27943 }
27944
27945
27946 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() {
27947   int jresult ;
27948   int result;
27949
27950   result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE;
27951   jresult = (int)result;
27952   return jresult;
27953 }
27954
27955
27956 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TOP_PLANE_DISTANCE_get() {
27957   int jresult ;
27958   int result;
27959
27960   result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE;
27961   jresult = (int)result;
27962   return jresult;
27963 }
27964
27965
27966 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() {
27967   int jresult ;
27968   int result;
27969
27970   result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE;
27971   jresult = (int)result;
27972   return jresult;
27973 }
27974
27975
27976 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TARGET_POSITION_get() {
27977   int jresult ;
27978   int result;
27979
27980   result = (int)Dali::CameraActor::Property::TARGET_POSITION;
27981   jresult = (int)result;
27982   return jresult;
27983 }
27984
27985
27986 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MATRIX_get() {
27987   int jresult ;
27988   int result;
27989
27990   result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX;
27991   jresult = (int)result;
27992   return jresult;
27993 }
27994
27995
27996 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_VIEW_MATRIX_get() {
27997   int jresult ;
27998   int result;
27999
28000   result = (int)Dali::CameraActor::Property::VIEW_MATRIX;
28001   jresult = (int)result;
28002   return jresult;
28003 }
28004
28005
28006 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_INVERT_Y_AXIS_get() {
28007   int jresult ;
28008   int result;
28009
28010   result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS;
28011   jresult = (int)result;
28012   return jresult;
28013 }
28014
28015
28016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor_Property() {
28017   void * jresult ;
28018   Dali::CameraActor::Property *result = 0 ;
28019
28020   {
28021     try {
28022       result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property();
28023     } CALL_CATCH_EXCEPTION(0);
28024   }
28025
28026   jresult = (void *)result;
28027   return jresult;
28028 }
28029
28030
28031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor_Property(void * jarg1) {
28032   Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ;
28033
28034   arg1 = (Dali::CameraActor::Property *)jarg1;
28035   {
28036     try {
28037       delete arg1;
28038     } CALL_CATCH_EXCEPTION();
28039   }
28040
28041 }
28042
28043
28044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_0() {
28045   void * jresult ;
28046   Dali::CameraActor *result = 0 ;
28047
28048   {
28049     try {
28050       result = (Dali::CameraActor *)new Dali::CameraActor();
28051     } CALL_CATCH_EXCEPTION(0);
28052   }
28053
28054   jresult = (void *)result;
28055   return jresult;
28056 }
28057
28058
28059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_0() {
28060   void * jresult ;
28061   Dali::CameraActor result;
28062
28063   {
28064     try {
28065       result = Dali::CameraActor::New();
28066     } CALL_CATCH_EXCEPTION(0);
28067   }
28068
28069   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
28070   return jresult;
28071 }
28072
28073
28074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_1(void * jarg1) {
28075   void * jresult ;
28076   Dali::Size *arg1 = 0 ;
28077   Dali::CameraActor result;
28078
28079   arg1 = (Dali::Size *)jarg1;
28080   if (!arg1) {
28081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
28082     return 0;
28083   }
28084   {
28085     try {
28086       result = Dali::CameraActor::New((Dali::Vector2 const &)*arg1);
28087     } CALL_CATCH_EXCEPTION(0);
28088   }
28089
28090   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
28091   return jresult;
28092 }
28093
28094
28095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_DownCast(void * jarg1) {
28096   void * jresult ;
28097   Dali::BaseHandle arg1 ;
28098   Dali::BaseHandle *argp1 ;
28099   Dali::CameraActor result;
28100
28101   argp1 = (Dali::BaseHandle *)jarg1;
28102   if (!argp1) {
28103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
28104     return 0;
28105   }
28106   arg1 = *argp1;
28107   {
28108     try {
28109       result = Dali::CameraActor::DownCast(arg1);
28110     } CALL_CATCH_EXCEPTION(0);
28111   }
28112
28113   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
28114   return jresult;
28115 }
28116
28117
28118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor(void * jarg1) {
28119   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28120
28121   arg1 = (Dali::CameraActor *)jarg1;
28122   {
28123     try {
28124       delete arg1;
28125     } CALL_CATCH_EXCEPTION();
28126   }
28127
28128 }
28129
28130
28131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_1(void * jarg1) {
28132   void * jresult ;
28133   Dali::CameraActor *arg1 = 0 ;
28134   Dali::CameraActor *result = 0 ;
28135
28136   arg1 = (Dali::CameraActor *)jarg1;
28137   if (!arg1) {
28138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
28139     return 0;
28140   }
28141   {
28142     try {
28143       result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1);
28144     } CALL_CATCH_EXCEPTION(0);
28145   }
28146
28147   jresult = (void *)result;
28148   return jresult;
28149 }
28150
28151
28152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_Assign(void * jarg1, void * jarg2) {
28153   void * jresult ;
28154   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28155   Dali::CameraActor *arg2 = 0 ;
28156   Dali::CameraActor *result = 0 ;
28157
28158   arg1 = (Dali::CameraActor *)jarg1;
28159   arg2 = (Dali::CameraActor *)jarg2;
28160   if (!arg2) {
28161     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
28162     return 0;
28163   }
28164   {
28165     try {
28166       result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2);
28167     } CALL_CATCH_EXCEPTION(0);
28168   }
28169
28170   jresult = (void *)result;
28171   return jresult;
28172 }
28173
28174
28175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetType(void * jarg1, int jarg2) {
28176   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28177   Dali::Camera::Type arg2 ;
28178
28179   arg1 = (Dali::CameraActor *)jarg1;
28180   arg2 = (Dali::Camera::Type)jarg2;
28181   {
28182     try {
28183       (arg1)->SetType(arg2);
28184     } CALL_CATCH_EXCEPTION();
28185   }
28186
28187 }
28188
28189
28190 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetType(void * jarg1) {
28191   int jresult ;
28192   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28193   Dali::Camera::Type result;
28194
28195   arg1 = (Dali::CameraActor *)jarg1;
28196   {
28197     try {
28198       result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType();
28199     } CALL_CATCH_EXCEPTION(0);
28200   }
28201
28202   jresult = (int)result;
28203   return jresult;
28204 }
28205
28206
28207 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetProjectionMode(void * jarg1, int jarg2) {
28208   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28209   Dali::Camera::ProjectionMode arg2 ;
28210
28211   arg1 = (Dali::CameraActor *)jarg1;
28212   arg2 = (Dali::Camera::ProjectionMode)jarg2;
28213   {
28214     try {
28215       (arg1)->SetProjectionMode(arg2);
28216     } CALL_CATCH_EXCEPTION();
28217   }
28218
28219 }
28220
28221
28222 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetProjectionMode(void * jarg1) {
28223   int jresult ;
28224   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28225   Dali::Camera::ProjectionMode result;
28226
28227   arg1 = (Dali::CameraActor *)jarg1;
28228   {
28229     try {
28230       result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode();
28231     } CALL_CATCH_EXCEPTION(0);
28232   }
28233
28234   jresult = (int)result;
28235   return jresult;
28236 }
28237
28238
28239 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFieldOfView(void * jarg1, float jarg2) {
28240   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28241   float arg2 ;
28242
28243   arg1 = (Dali::CameraActor *)jarg1;
28244   arg2 = (float)jarg2;
28245   {
28246     try {
28247       (arg1)->SetFieldOfView(arg2);
28248     } CALL_CATCH_EXCEPTION();
28249   }
28250
28251 }
28252
28253
28254 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFieldOfView(void * jarg1) {
28255   float jresult ;
28256   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28257   float result;
28258
28259   arg1 = (Dali::CameraActor *)jarg1;
28260   {
28261     try {
28262       result = (float)(arg1)->GetFieldOfView();
28263     } CALL_CATCH_EXCEPTION(0);
28264   }
28265
28266   jresult = result;
28267   return jresult;
28268 }
28269
28270
28271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetAspectRatio(void * jarg1, float jarg2) {
28272   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28273   float arg2 ;
28274
28275   arg1 = (Dali::CameraActor *)jarg1;
28276   arg2 = (float)jarg2;
28277   {
28278     try {
28279       (arg1)->SetAspectRatio(arg2);
28280     } CALL_CATCH_EXCEPTION();
28281   }
28282
28283 }
28284
28285
28286 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetAspectRatio(void * jarg1) {
28287   float jresult ;
28288   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28289   float result;
28290
28291   arg1 = (Dali::CameraActor *)jarg1;
28292   {
28293     try {
28294       result = (float)(arg1)->GetAspectRatio();
28295     } CALL_CATCH_EXCEPTION(0);
28296   }
28297
28298   jresult = result;
28299   return jresult;
28300 }
28301
28302
28303 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) {
28304   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28305   float arg2 ;
28306
28307   arg1 = (Dali::CameraActor *)jarg1;
28308   arg2 = (float)jarg2;
28309   {
28310     try {
28311       (arg1)->SetNearClippingPlane(arg2);
28312     } CALL_CATCH_EXCEPTION();
28313   }
28314
28315 }
28316
28317
28318 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetNearClippingPlane(void * jarg1) {
28319   float jresult ;
28320   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28321   float result;
28322
28323   arg1 = (Dali::CameraActor *)jarg1;
28324   {
28325     try {
28326       result = (float)(arg1)->GetNearClippingPlane();
28327     } CALL_CATCH_EXCEPTION(0);
28328   }
28329
28330   jresult = result;
28331   return jresult;
28332 }
28333
28334
28335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) {
28336   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28337   float arg2 ;
28338
28339   arg1 = (Dali::CameraActor *)jarg1;
28340   arg2 = (float)jarg2;
28341   {
28342     try {
28343       (arg1)->SetFarClippingPlane(arg2);
28344     } CALL_CATCH_EXCEPTION();
28345   }
28346
28347 }
28348
28349
28350 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFarClippingPlane(void * jarg1) {
28351   float jresult ;
28352   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28353   float result;
28354
28355   arg1 = (Dali::CameraActor *)jarg1;
28356   {
28357     try {
28358       result = (float)(arg1)->GetFarClippingPlane();
28359     } CALL_CATCH_EXCEPTION(0);
28360   }
28361
28362   jresult = result;
28363   return jresult;
28364 }
28365
28366
28367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) {
28368   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28369   Dali::Vector3 *arg2 = 0 ;
28370
28371   arg1 = (Dali::CameraActor *)jarg1;
28372   arg2 = (Dali::Vector3 *)jarg2;
28373   if (!arg2) {
28374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
28375     return ;
28376   }
28377   {
28378     try {
28379       (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2);
28380     } CALL_CATCH_EXCEPTION();
28381   }
28382
28383 }
28384
28385
28386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_GetTargetPosition(void * jarg1) {
28387   void * jresult ;
28388   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28389   Dali::Vector3 result;
28390
28391   arg1 = (Dali::CameraActor *)jarg1;
28392   {
28393     try {
28394       result = ((Dali::CameraActor const *)arg1)->GetTargetPosition();
28395     } CALL_CATCH_EXCEPTION(0);
28396   }
28397
28398   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
28399   return jresult;
28400 }
28401
28402
28403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetInvertYAxis(void * jarg1, unsigned int jarg2) {
28404   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28405   bool arg2 ;
28406
28407   arg1 = (Dali::CameraActor *)jarg1;
28408   arg2 = jarg2 ? true : false;
28409   {
28410     try {
28411       (arg1)->SetInvertYAxis(arg2);
28412     } CALL_CATCH_EXCEPTION();
28413   }
28414
28415 }
28416
28417
28418 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CameraActor_GetInvertYAxis(void * jarg1) {
28419   unsigned int jresult ;
28420   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28421   bool result;
28422
28423   arg1 = (Dali::CameraActor *)jarg1;
28424   {
28425     try {
28426       result = (bool)(arg1)->GetInvertYAxis();
28427     } CALL_CATCH_EXCEPTION(0);
28428   }
28429
28430   jresult = result;
28431   return jresult;
28432 }
28433
28434
28435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) {
28436   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28437   Dali::Size *arg2 = 0 ;
28438
28439   arg1 = (Dali::CameraActor *)jarg1;
28440   arg2 = (Dali::Size *)jarg2;
28441   if (!arg2) {
28442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
28443     return ;
28444   }
28445   {
28446     try {
28447       (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2);
28448     } CALL_CATCH_EXCEPTION();
28449   }
28450
28451 }
28452
28453
28454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) {
28455   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28456   Dali::Size *arg2 = 0 ;
28457
28458   arg1 = (Dali::CameraActor *)jarg1;
28459   arg2 = (Dali::Size *)jarg2;
28460   if (!arg2) {
28461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
28462     return ;
28463   }
28464   {
28465     try {
28466       (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2);
28467     } CALL_CATCH_EXCEPTION();
28468   }
28469
28470 }
28471
28472
28473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7) {
28474   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28475   float arg2 ;
28476   float arg3 ;
28477   float arg4 ;
28478   float arg5 ;
28479   float arg6 ;
28480   float arg7 ;
28481
28482   arg1 = (Dali::CameraActor *)jarg1;
28483   arg2 = (float)jarg2;
28484   arg3 = (float)jarg3;
28485   arg4 = (float)jarg4;
28486   arg5 = (float)jarg5;
28487   arg6 = (float)jarg6;
28488   arg7 = (float)jarg7;
28489   {
28490     try {
28491       (arg1)->SetOrthographicProjection(arg2,arg3,arg4,arg5,arg6,arg7);
28492     } CALL_CATCH_EXCEPTION();
28493   }
28494
28495 }
28496
28497
28498 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_0() {
28499   void * jresult ;
28500   std::pair< std::string,Dali::Property::Value > *result = 0 ;
28501
28502   {
28503     try {
28504       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >();
28505     } CALL_CATCH_EXCEPTION(0);
28506   }
28507
28508   jresult = (void *)result;
28509   return jresult;
28510 }
28511
28512
28513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) {
28514   void * jresult ;
28515   std::string arg1 ;
28516   Dali::Property::Value arg2 ;
28517   Dali::Property::Value *argp2 ;
28518   std::pair< std::string,Dali::Property::Value > *result = 0 ;
28519
28520   if (!jarg1) {
28521     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
28522     return 0;
28523   }
28524   (&arg1)->assign(jarg1);
28525   argp2 = (Dali::Property::Value *)jarg2;
28526   if (!argp2) {
28527     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
28528     return 0;
28529   }
28530   arg2 = *argp2;
28531   {
28532     try {
28533       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2);
28534     } CALL_CATCH_EXCEPTION(0);
28535   }
28536
28537   jresult = (void *)result;
28538   return jresult;
28539 }
28540
28541
28542 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_2(void * jarg1) {
28543   void * jresult ;
28544   std::pair< std::string,Dali::Property::Value > *arg1 = 0 ;
28545   std::pair< std::string,Dali::Property::Value > *result = 0 ;
28546
28547   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
28548   if (!arg1) {
28549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0);
28550     return 0;
28551   }
28552   {
28553     try {
28554       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);
28555     } CALL_CATCH_EXCEPTION(0);
28556   }
28557
28558   jresult = (void *)result;
28559   return jresult;
28560 }
28561
28562
28563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_first_set(void * jarg1, char * jarg2) {
28564   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
28565   std::string *arg2 = 0 ;
28566
28567   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
28568   if (!jarg2) {
28569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
28570     return ;
28571   }
28572   std::string arg2_str(jarg2);
28573   arg2 = &arg2_str;
28574   if (arg1) (arg1)->first = *arg2;
28575
28576   //argout typemap for const std::string&
28577
28578 }
28579
28580
28581 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StringValuePair_first_get(void * jarg1) {
28582   char * jresult ;
28583   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
28584   std::string *result = 0 ;
28585
28586   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
28587   result = (std::string *) & ((arg1)->first);
28588   jresult = SWIG_csharp_string_callback(result->c_str());
28589   return jresult;
28590 }
28591
28592
28593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_second_set(void * jarg1, void * jarg2) {
28594   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
28595   Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ;
28596
28597   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
28598   arg2 = (Dali::Property::Value *)jarg2;
28599   if (arg1) (arg1)->second = *arg2;
28600 }
28601
28602
28603 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StringValuePair_second_get(void * jarg1) {
28604   void * jresult ;
28605   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
28606   Dali::Property::Value *result = 0 ;
28607
28608   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
28609   result = (Dali::Property::Value *)& ((arg1)->second);
28610   jresult = (void *)result;
28611   return jresult;
28612 }
28613
28614
28615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StringValuePair(void * jarg1) {
28616   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
28617
28618   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
28619   {
28620     try {
28621       delete arg1;
28622     } CALL_CATCH_EXCEPTION();
28623   }
28624
28625 }
28626
28627
28628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Clear(void * jarg1) {
28629   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28630
28631   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28632   {
28633     try {
28634       (arg1)->clear();
28635     } CALL_CATCH_EXCEPTION();
28636   }
28637
28638 }
28639
28640
28641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Add(void * jarg1, void * jarg2) {
28642   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28643   Dali::TouchPoint *arg2 = 0 ;
28644
28645   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28646   arg2 = (Dali::TouchPoint *)jarg2;
28647   if (!arg2) {
28648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
28649     return ;
28650   }
28651   {
28652     try {
28653       (arg1)->push_back((Dali::TouchPoint const &)*arg2);
28654     } CALL_CATCH_EXCEPTION();
28655   }
28656
28657 }
28658
28659
28660 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_size(void * jarg1) {
28661   unsigned long jresult ;
28662   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28663   std::vector< Dali::TouchPoint >::size_type result;
28664
28665   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28666   {
28667     try {
28668       result = ((std::vector< Dali::TouchPoint > const *)arg1)->size();
28669     } CALL_CATCH_EXCEPTION(0);
28670   }
28671
28672   jresult = (unsigned long)result;
28673   return jresult;
28674 }
28675
28676
28677 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_capacity(void * jarg1) {
28678   unsigned long jresult ;
28679   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28680   std::vector< Dali::TouchPoint >::size_type result;
28681
28682   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28683   {
28684     try {
28685       result = ((std::vector< Dali::TouchPoint > const *)arg1)->capacity();
28686     } CALL_CATCH_EXCEPTION(0);
28687   }
28688
28689   jresult = (unsigned long)result;
28690   return jresult;
28691 }
28692
28693
28694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) {
28695   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28696   std::vector< Dali::TouchPoint >::size_type arg2 ;
28697
28698   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28699   arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2;
28700   {
28701     try {
28702       (arg1)->reserve(arg2);
28703     } CALL_CATCH_EXCEPTION();
28704   }
28705
28706 }
28707
28708
28709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_0() {
28710   void * jresult ;
28711   std::vector< Dali::TouchPoint > *result = 0 ;
28712
28713   {
28714     try {
28715       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >();
28716     } CALL_CATCH_EXCEPTION(0);
28717   }
28718
28719   jresult = (void *)result;
28720   return jresult;
28721 }
28722
28723
28724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_1(void * jarg1) {
28725   void * jresult ;
28726   std::vector< Dali::TouchPoint > *arg1 = 0 ;
28727   std::vector< Dali::TouchPoint > *result = 0 ;
28728
28729   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28730   if (!arg1) {
28731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
28732     return 0;
28733   }
28734   {
28735     try {
28736       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1);
28737     } CALL_CATCH_EXCEPTION(0);
28738   }
28739
28740   jresult = (void *)result;
28741   return jresult;
28742 }
28743
28744
28745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_2(int jarg1) {
28746   void * jresult ;
28747   int arg1 ;
28748   std::vector< Dali::TouchPoint > *result = 0 ;
28749
28750   arg1 = (int)jarg1;
28751   {
28752     try {
28753       try {
28754         result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1);
28755       }
28756       catch(std::out_of_range &_e) {
28757         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
28758         return 0;
28759       }
28760
28761     } CALL_CATCH_EXCEPTION(0);
28762   }
28763
28764   jresult = (void *)result;
28765   return jresult;
28766 }
28767
28768
28769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) {
28770   void * jresult ;
28771   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28772   int arg2 ;
28773   SwigValueWrapper< Dali::TouchPoint > result;
28774
28775   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28776   arg2 = (int)jarg2;
28777   {
28778     try {
28779       try {
28780         result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2);
28781       }
28782       catch(std::out_of_range &_e) {
28783         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
28784         return 0;
28785       }
28786
28787     } CALL_CATCH_EXCEPTION(0);
28788   }
28789
28790   jresult = new Dali::TouchPoint((const Dali::TouchPoint &)result);
28791   return jresult;
28792 }
28793
28794
28795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitem(void * jarg1, int jarg2) {
28796   void * jresult ;
28797   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28798   int arg2 ;
28799   Dali::TouchPoint *result = 0 ;
28800
28801   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28802   arg2 = (int)jarg2;
28803   {
28804     try {
28805       try {
28806         result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2);
28807       }
28808       catch(std::out_of_range &_e) {
28809         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
28810         return 0;
28811       }
28812
28813     } CALL_CATCH_EXCEPTION(0);
28814   }
28815
28816   jresult = (void *)result;
28817   return jresult;
28818 }
28819
28820
28821 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
28822   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28823   int arg2 ;
28824   Dali::TouchPoint *arg3 = 0 ;
28825
28826   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28827   arg2 = (int)jarg2;
28828   arg3 = (Dali::TouchPoint *)jarg3;
28829   if (!arg3) {
28830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
28831     return ;
28832   }
28833   {
28834     try {
28835       try {
28836         std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3);
28837       }
28838       catch(std::out_of_range &_e) {
28839         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
28840         return ;
28841       }
28842
28843     } CALL_CATCH_EXCEPTION();
28844   }
28845
28846 }
28847
28848
28849 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_AddRange(void * jarg1, void * jarg2) {
28850   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28851   std::vector< Dali::TouchPoint > *arg2 = 0 ;
28852
28853   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28854   arg2 = (std::vector< Dali::TouchPoint > *)jarg2;
28855   if (!arg2) {
28856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
28857     return ;
28858   }
28859   {
28860     try {
28861       std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2);
28862     } CALL_CATCH_EXCEPTION();
28863   }
28864
28865 }
28866
28867
28868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
28869   void * jresult ;
28870   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28871   int arg2 ;
28872   int arg3 ;
28873   std::vector< Dali::TouchPoint > *result = 0 ;
28874
28875   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28876   arg2 = (int)jarg2;
28877   arg3 = (int)jarg3;
28878   {
28879     try {
28880       try {
28881         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3);
28882       }
28883       catch(std::out_of_range &_e) {
28884         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
28885         return 0;
28886       }
28887       catch(std::invalid_argument &_e) {
28888         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
28889         return 0;
28890       }
28891
28892     } CALL_CATCH_EXCEPTION(0);
28893   }
28894
28895   jresult = (void *)result;
28896   return jresult;
28897 }
28898
28899
28900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
28901   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28902   int arg2 ;
28903   Dali::TouchPoint *arg3 = 0 ;
28904
28905   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28906   arg2 = (int)jarg2;
28907   arg3 = (Dali::TouchPoint *)jarg3;
28908   if (!arg3) {
28909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
28910     return ;
28911   }
28912   {
28913     try {
28914       try {
28915         std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3);
28916       }
28917       catch(std::out_of_range &_e) {
28918         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
28919         return ;
28920       }
28921
28922     } CALL_CATCH_EXCEPTION();
28923   }
28924
28925 }
28926
28927
28928 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
28929   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28930   int arg2 ;
28931   std::vector< Dali::TouchPoint > *arg3 = 0 ;
28932
28933   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28934   arg2 = (int)jarg2;
28935   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
28936   if (!arg3) {
28937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
28938     return ;
28939   }
28940   {
28941     try {
28942       try {
28943         std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
28944       }
28945       catch(std::out_of_range &_e) {
28946         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
28947         return ;
28948       }
28949
28950     } CALL_CATCH_EXCEPTION();
28951   }
28952
28953 }
28954
28955
28956 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveAt(void * jarg1, int jarg2) {
28957   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28958   int arg2 ;
28959
28960   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28961   arg2 = (int)jarg2;
28962   {
28963     try {
28964       try {
28965         std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2);
28966       }
28967       catch(std::out_of_range &_e) {
28968         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
28969         return ;
28970       }
28971
28972     } CALL_CATCH_EXCEPTION();
28973   }
28974
28975 }
28976
28977
28978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
28979   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28980   int arg2 ;
28981   int arg3 ;
28982
28983   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28984   arg2 = (int)jarg2;
28985   arg3 = (int)jarg3;
28986   {
28987     try {
28988       try {
28989         std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3);
28990       }
28991       catch(std::out_of_range &_e) {
28992         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
28993         return ;
28994       }
28995       catch(std::invalid_argument &_e) {
28996         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
28997         return ;
28998       }
28999
29000     } CALL_CATCH_EXCEPTION();
29001   }
29002
29003 }
29004
29005
29006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_Repeat(void * jarg1, int jarg2) {
29007   void * jresult ;
29008   Dali::TouchPoint *arg1 = 0 ;
29009   int arg2 ;
29010   std::vector< Dali::TouchPoint > *result = 0 ;
29011
29012   arg1 = (Dali::TouchPoint *)jarg1;
29013   if (!arg1) {
29014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
29015     return 0;
29016   }
29017   arg2 = (int)jarg2;
29018   {
29019     try {
29020       try {
29021         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2);
29022       }
29023       catch(std::out_of_range &_e) {
29024         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
29025         return 0;
29026       }
29027
29028     } CALL_CATCH_EXCEPTION(0);
29029   }
29030
29031   jresult = (void *)result;
29032   return jresult;
29033 }
29034
29035
29036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_0(void * jarg1) {
29037   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
29038
29039   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
29040   {
29041     try {
29042       std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1);
29043     } CALL_CATCH_EXCEPTION();
29044   }
29045
29046 }
29047
29048
29049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
29050   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
29051   int arg2 ;
29052   int arg3 ;
29053
29054   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
29055   arg2 = (int)jarg2;
29056   arg3 = (int)jarg3;
29057   {
29058     try {
29059       try {
29060         std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
29061       }
29062       catch(std::out_of_range &_e) {
29063         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
29064         return ;
29065       }
29066       catch(std::invalid_argument &_e) {
29067         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
29068         return ;
29069       }
29070
29071     } CALL_CATCH_EXCEPTION();
29072   }
29073
29074 }
29075
29076
29077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
29078   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
29079   int arg2 ;
29080   std::vector< Dali::TouchPoint > *arg3 = 0 ;
29081
29082   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
29083   arg2 = (int)jarg2;
29084   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
29085   if (!arg3) {
29086     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
29087     return ;
29088   }
29089   {
29090     try {
29091       try {
29092         std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
29093       }
29094       catch(std::out_of_range &_e) {
29095         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
29096         return ;
29097       }
29098
29099     } CALL_CATCH_EXCEPTION();
29100   }
29101
29102 }
29103
29104
29105 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPointContainer(void * jarg1) {
29106   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
29107
29108   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
29109   {
29110     try {
29111       delete arg1;
29112     } CALL_CATCH_EXCEPTION();
29113   }
29114
29115 }
29116
29117
29118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_0() {
29119   void * jresult ;
29120   Dali::Rect< int > *result = 0 ;
29121
29122   {
29123     try {
29124       result = (Dali::Rect< int > *)new Dali::Rect< int >();
29125     } CALL_CATCH_EXCEPTION(0);
29126   }
29127
29128   jresult = (void *)result;
29129   return jresult;
29130 }
29131
29132
29133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) {
29134   void * jresult ;
29135   int arg1 ;
29136   int arg2 ;
29137   int arg3 ;
29138   int arg4 ;
29139   Dali::Rect< int > *result = 0 ;
29140
29141   arg1 = (int)jarg1;
29142   arg2 = (int)jarg2;
29143   arg3 = (int)jarg3;
29144   arg4 = (int)jarg4;
29145   {
29146     try {
29147       result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4);
29148     } CALL_CATCH_EXCEPTION(0);
29149   }
29150
29151   jresult = (void *)result;
29152   return jresult;
29153 }
29154
29155
29156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_2(void * jarg1) {
29157   void * jresult ;
29158   Dali::Rect< int > *arg1 = 0 ;
29159   Dali::Rect< int > *result = 0 ;
29160
29161   arg1 = (Dali::Rect< int > *)jarg1;
29162   if (!arg1) {
29163     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
29164     return 0;
29165   }
29166   {
29167     try {
29168       result = (Dali::Rect< int > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1);
29169     } CALL_CATCH_EXCEPTION(0);
29170   }
29171
29172   jresult = (void *)result;
29173   return jresult;
29174 }
29175
29176
29177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rectangle_Assign(void * jarg1, void * jarg2) {
29178   void * jresult ;
29179   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29180   Dali::Rect< int > *arg2 = 0 ;
29181   Dali::Rect< int > *result = 0 ;
29182
29183   arg1 = (Dali::Rect< int > *)jarg1;
29184   arg2 = (Dali::Rect< int > *)jarg2;
29185   if (!arg2) {
29186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
29187     return 0;
29188   }
29189   {
29190     try {
29191       result = (Dali::Rect< int > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2);
29192     } CALL_CATCH_EXCEPTION(0);
29193   }
29194
29195   jresult = (void *)result;
29196   return jresult;
29197 }
29198
29199
29200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
29201   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29202   int arg2 ;
29203   int arg3 ;
29204   int arg4 ;
29205   int arg5 ;
29206
29207   arg1 = (Dali::Rect< int > *)jarg1;
29208   arg2 = (int)jarg2;
29209   arg3 = (int)jarg3;
29210   arg4 = (int)jarg4;
29211   arg5 = (int)jarg5;
29212   {
29213     try {
29214       (arg1)->Set(arg2,arg3,arg4,arg5);
29215     } CALL_CATCH_EXCEPTION();
29216   }
29217
29218 }
29219
29220
29221 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_IsEmpty(void * jarg1) {
29222   unsigned int jresult ;
29223   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29224   bool result;
29225
29226   arg1 = (Dali::Rect< int > *)jarg1;
29227   {
29228     try {
29229       result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty();
29230     } CALL_CATCH_EXCEPTION(0);
29231   }
29232
29233   jresult = result;
29234   return jresult;
29235 }
29236
29237
29238 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Left(void * jarg1) {
29239   int jresult ;
29240   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29241   int result;
29242
29243   arg1 = (Dali::Rect< int > *)jarg1;
29244   {
29245     try {
29246       result = (int)((Dali::Rect< int > const *)arg1)->Left();
29247     } CALL_CATCH_EXCEPTION(0);
29248   }
29249
29250   jresult = result;
29251   return jresult;
29252 }
29253
29254
29255 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Right(void * jarg1) {
29256   int jresult ;
29257   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29258   int result;
29259
29260   arg1 = (Dali::Rect< int > *)jarg1;
29261   {
29262     try {
29263       result = (int)((Dali::Rect< int > const *)arg1)->Right();
29264     } CALL_CATCH_EXCEPTION(0);
29265   }
29266
29267   jresult = result;
29268   return jresult;
29269 }
29270
29271
29272 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Top(void * jarg1) {
29273   int jresult ;
29274   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29275   int result;
29276
29277   arg1 = (Dali::Rect< int > *)jarg1;
29278   {
29279     try {
29280       result = (int)((Dali::Rect< int > const *)arg1)->Top();
29281     } CALL_CATCH_EXCEPTION(0);
29282   }
29283
29284   jresult = result;
29285   return jresult;
29286 }
29287
29288
29289 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Bottom(void * jarg1) {
29290   int jresult ;
29291   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29292   int result;
29293
29294   arg1 = (Dali::Rect< int > *)jarg1;
29295   {
29296     try {
29297       result = (int)((Dali::Rect< int > const *)arg1)->Bottom();
29298     } CALL_CATCH_EXCEPTION(0);
29299   }
29300
29301   jresult = result;
29302   return jresult;
29303 }
29304
29305
29306 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Area(void * jarg1) {
29307   int jresult ;
29308   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29309   int result;
29310
29311   arg1 = (Dali::Rect< int > *)jarg1;
29312   {
29313     try {
29314       result = (int)((Dali::Rect< int > const *)arg1)->Area();
29315     } CALL_CATCH_EXCEPTION(0);
29316   }
29317
29318   jresult = result;
29319   return jresult;
29320 }
29321
29322
29323 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Intersects(void * jarg1, void * jarg2) {
29324   unsigned int jresult ;
29325   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29326   Dali::Rect< int > *arg2 = 0 ;
29327   bool result;
29328
29329   arg1 = (Dali::Rect< int > *)jarg1;
29330   arg2 = (Dali::Rect< int > *)jarg2;
29331   if (!arg2) {
29332     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
29333     return 0;
29334   }
29335   {
29336     try {
29337       result = (bool)((Dali::Rect< int > const *)arg1)->Intersects((Dali::Rect< int > const &)*arg2);
29338     } CALL_CATCH_EXCEPTION(0);
29339   }
29340
29341   jresult = result;
29342   return jresult;
29343 }
29344
29345
29346 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Contains(void * jarg1, void * jarg2) {
29347   unsigned int jresult ;
29348   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29349   Dali::Rect< int > *arg2 = 0 ;
29350   bool result;
29351
29352   arg1 = (Dali::Rect< int > *)jarg1;
29353   arg2 = (Dali::Rect< int > *)jarg2;
29354   if (!arg2) {
29355     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
29356     return 0;
29357   }
29358   {
29359     try {
29360       result = (bool)((Dali::Rect< int > const *)arg1)->Contains((Dali::Rect< int > const &)*arg2);
29361     } CALL_CATCH_EXCEPTION(0);
29362   }
29363
29364   jresult = result;
29365   return jresult;
29366 }
29367
29368
29369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_x_set(void * jarg1, int jarg2) {
29370   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29371   int arg2 ;
29372
29373   arg1 = (Dali::Rect< int > *)jarg1;
29374   arg2 = (int)jarg2;
29375   if (arg1) (arg1)->x = arg2;
29376 }
29377
29378
29379 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_x_get(void * jarg1) {
29380   int jresult ;
29381   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29382   int result;
29383
29384   arg1 = (Dali::Rect< int > *)jarg1;
29385   result = (int) ((arg1)->x);
29386   jresult = result;
29387   return jresult;
29388 }
29389
29390
29391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_left_set(void * jarg1, int jarg2) {
29392   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29393   int arg2 ;
29394
29395   arg1 = (Dali::Rect< int > *)jarg1;
29396   arg2 = (int)jarg2;
29397   if (arg1) (arg1)->left = arg2;
29398 }
29399
29400
29401 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_left_get(void * jarg1) {
29402   int jresult ;
29403   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29404   int result;
29405
29406   arg1 = (Dali::Rect< int > *)jarg1;
29407   result = (int) ((arg1)->left);
29408   jresult = result;
29409   return jresult;
29410 }
29411
29412
29413 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_y_set(void * jarg1, int jarg2) {
29414   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29415   int arg2 ;
29416
29417   arg1 = (Dali::Rect< int > *)jarg1;
29418   arg2 = (int)jarg2;
29419   if (arg1) (arg1)->y = arg2;
29420 }
29421
29422
29423 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_y_get(void * jarg1) {
29424   int jresult ;
29425   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29426   int result;
29427
29428   arg1 = (Dali::Rect< int > *)jarg1;
29429   result = (int) ((arg1)->y);
29430   jresult = result;
29431   return jresult;
29432 }
29433
29434
29435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_right_set(void * jarg1, int jarg2) {
29436   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29437   int arg2 ;
29438
29439   arg1 = (Dali::Rect< int > *)jarg1;
29440   arg2 = (int)jarg2;
29441   if (arg1) (arg1)->right = arg2;
29442 }
29443
29444
29445 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_right_get(void * jarg1) {
29446   int jresult ;
29447   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29448   int result;
29449
29450   arg1 = (Dali::Rect< int > *)jarg1;
29451   result = (int) ((arg1)->right);
29452   jresult = result;
29453   return jresult;
29454 }
29455
29456
29457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_width_set(void * jarg1, int jarg2) {
29458   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29459   int arg2 ;
29460
29461   arg1 = (Dali::Rect< int > *)jarg1;
29462   arg2 = (int)jarg2;
29463   if (arg1) (arg1)->width = arg2;
29464 }
29465
29466
29467 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_width_get(void * jarg1) {
29468   int jresult ;
29469   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29470   int result;
29471
29472   arg1 = (Dali::Rect< int > *)jarg1;
29473   result = (int) ((arg1)->width);
29474   jresult = result;
29475   return jresult;
29476 }
29477
29478
29479 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_bottom_set(void * jarg1, int jarg2) {
29480   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29481   int arg2 ;
29482
29483   arg1 = (Dali::Rect< int > *)jarg1;
29484   arg2 = (int)jarg2;
29485   if (arg1) (arg1)->bottom = arg2;
29486 }
29487
29488
29489 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_bottom_get(void * jarg1) {
29490   int jresult ;
29491   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29492   int result;
29493
29494   arg1 = (Dali::Rect< int > *)jarg1;
29495   result = (int) ((arg1)->bottom);
29496   jresult = result;
29497   return jresult;
29498 }
29499
29500
29501 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_height_set(void * jarg1, int jarg2) {
29502   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29503   int arg2 ;
29504
29505   arg1 = (Dali::Rect< int > *)jarg1;
29506   arg2 = (int)jarg2;
29507   if (arg1) (arg1)->height = arg2;
29508 }
29509
29510
29511 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_height_get(void * jarg1) {
29512   int jresult ;
29513   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29514   int result;
29515
29516   arg1 = (Dali::Rect< int > *)jarg1;
29517   result = (int) ((arg1)->height);
29518   jresult = result;
29519   return jresult;
29520 }
29521
29522
29523 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_top_set(void * jarg1, int jarg2) {
29524   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29525   int arg2 ;
29526
29527   arg1 = (Dali::Rect< int > *)jarg1;
29528   arg2 = (int)jarg2;
29529   if (arg1) (arg1)->top = arg2;
29530 }
29531
29532
29533 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_top_get(void * jarg1) {
29534   int jresult ;
29535   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29536   int result;
29537
29538   arg1 = (Dali::Rect< int > *)jarg1;
29539   result = (int) ((arg1)->top);
29540   jresult = result;
29541   return jresult;
29542 }
29543
29544
29545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rectangle(void * jarg1) {
29546   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29547
29548   arg1 = (Dali::Rect< int > *)jarg1;
29549   {
29550     try {
29551       delete arg1;
29552     } CALL_CATCH_EXCEPTION();
29553   }
29554
29555 }
29556
29557
29558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_0() {
29559   void * jresult ;
29560   Dali::Rect< float > *result = 0 ;
29561
29562   {
29563     try {
29564       result = (Dali::Rect< float > *)new Dali::Rect< float >();
29565     } CALL_CATCH_EXCEPTION(0);
29566   }
29567
29568   jresult = (void *)result;
29569   return jresult;
29570 }
29571
29572
29573 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
29574   void * jresult ;
29575   float arg1 ;
29576   float arg2 ;
29577   float arg3 ;
29578   float arg4 ;
29579   Dali::Rect< float > *result = 0 ;
29580
29581   arg1 = (float)jarg1;
29582   arg2 = (float)jarg2;
29583   arg3 = (float)jarg4;
29584   arg4 = (float)jarg3;
29585   {
29586     try {
29587       result = (Dali::Rect< float > *)new Dali::Rect< float >(arg1,arg2,arg3,arg4);
29588     } CALL_CATCH_EXCEPTION(0);
29589   }
29590
29591   jresult = (void *)result;
29592   return jresult;
29593 }
29594
29595
29596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_2(void * jarg1) {
29597   void * jresult ;
29598   Dali::Rect< float > *arg1 = 0 ;
29599   Dali::Rect< float > *result = 0 ;
29600
29601   arg1 = (Dali::Rect< float > *)jarg1;
29602   if (!arg1) {
29603     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
29604     return 0;
29605   }
29606   {
29607     try {
29608       result = (Dali::Rect< float > *)new Dali::Rect< float >((Dali::Rect< float > const &)*arg1);
29609     } CALL_CATCH_EXCEPTION(0);
29610   }
29611
29612   jresult = (void *)result;
29613   return jresult;
29614 }
29615
29616
29617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PaddingType_Assign(void * jarg1, void * jarg2) {
29618   void * jresult ;
29619   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
29620   Dali::Rect< float > *arg2 = 0 ;
29621   Dali::Rect< float > *result = 0 ;
29622
29623   arg1 = (Dali::Rect< float > *)jarg1;
29624   arg2 = (Dali::Rect< float > *)jarg2;
29625   if (!arg2) {
29626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
29627     return 0;
29628   }
29629   {
29630     try {
29631       result = (Dali::Rect< float > *) &(arg1)->operator =((Dali::Rect< float > const &)*arg2);
29632     } CALL_CATCH_EXCEPTION(0);
29633   }
29634
29635   jresult = (void *)result;
29636   return jresult;
29637 }
29638
29639
29640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_Set(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
29641   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
29642   float arg2 ;
29643   float arg3 ;
29644   float arg4 ;
29645   float arg5 ;
29646
29647   arg1 = (Dali::Rect< float > *)jarg1;
29648   arg2 = (float)jarg2;
29649   arg3 = (float)jarg3;
29650   arg4 = (float)jarg5;
29651   arg5 = (float)jarg4;
29652   {
29653     try {
29654       (arg1)->Set(arg2,arg3,arg4,arg5);
29655     } CALL_CATCH_EXCEPTION();
29656   }
29657
29658 }
29659
29660
29661 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_left_set(void * jarg1, float jarg2) {
29662   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
29663   float arg2 ;
29664
29665   arg1 = (Dali::Rect< float > *)jarg1;
29666   arg2 = (float)jarg2;
29667   if (arg1) (arg1)->left = arg2;
29668 }
29669
29670
29671 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_left_get(void * jarg1) {
29672   float jresult ;
29673   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
29674   float result;
29675
29676   arg1 = (Dali::Rect< float > *)jarg1;
29677   result = (float) ((arg1)->left);
29678   jresult = result;
29679   return jresult;
29680 }
29681
29682
29683 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_start_set(void * jarg1, float jarg2) {
29684   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
29685   float arg2 ;
29686
29687   arg1 = (Dali::Rect< float > *)jarg1;
29688   arg2 = (float)jarg2;
29689   if (arg1) (arg1)->left = arg2;
29690 }
29691
29692
29693 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_start_get(void * jarg1) {
29694   float jresult ;
29695   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
29696   float result;
29697
29698   arg1 = (Dali::Rect< float > *)jarg1;
29699   result = (float) ((arg1)->left);
29700   jresult = result;
29701   return jresult;
29702 }
29703
29704
29705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_right_set(void * jarg1, float jarg2) {
29706   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
29707   float arg2 ;
29708
29709   arg1 = (Dali::Rect< float > *)jarg1;
29710   arg2 = (float)jarg2;
29711   if (arg1) (arg1)->right = arg2;
29712 }
29713
29714
29715 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_right_get(void * jarg1) {
29716   float jresult ;
29717   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
29718   float result;
29719
29720   arg1 = (Dali::Rect< float > *)jarg1;
29721   result = (float) ((arg1)->right);
29722   jresult = result;
29723   return jresult;
29724 }
29725
29726
29727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_end_set(void * jarg1, float jarg2) {
29728   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
29729   float arg2 ;
29730
29731   arg1 = (Dali::Rect< float > *)jarg1;
29732   arg2 = (float)jarg2;
29733   if (arg1) (arg1)->right = arg2;
29734 }
29735
29736
29737 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_end_get(void * jarg1) {
29738   float jresult ;
29739   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
29740   float result;
29741
29742   arg1 = (Dali::Rect< float > *)jarg1;
29743   result = (float) ((arg1)->right);
29744   jresult = result;
29745   return jresult;
29746 }
29747
29748
29749 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_bottom_set(void * jarg1, float jarg2) {
29750   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
29751   float arg2 ;
29752
29753   arg1 = (Dali::Rect< float > *)jarg1;
29754   arg2 = (float)jarg2;
29755   if (arg1) (arg1)->bottom = arg2;
29756 }
29757
29758
29759 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_bottom_get(void * jarg1) {
29760   float jresult ;
29761   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
29762   float result;
29763
29764   arg1 = (Dali::Rect< float > *)jarg1;
29765   result = (float) ((arg1)->bottom);
29766   jresult = result;
29767   return jresult;
29768 }
29769
29770
29771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_top_set(void * jarg1, float jarg2) {
29772   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
29773   float arg2 ;
29774
29775   arg1 = (Dali::Rect< float > *)jarg1;
29776   arg2 = (float)jarg2;
29777   if (arg1) (arg1)->top = arg2;
29778 }
29779
29780
29781 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_top_get(void * jarg1) {
29782   float jresult ;
29783   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
29784   float result;
29785
29786   arg1 = (Dali::Rect< float > *)jarg1;
29787   result = (float) ((arg1)->top);
29788   jresult = result;
29789   return jresult;
29790 }
29791
29792
29793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PaddingType(void * jarg1) {
29794   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
29795
29796   arg1 = (Dali::Rect< float > *)jarg1;
29797   {
29798     try {
29799       delete arg1;
29800     } CALL_CATCH_EXCEPTION();
29801   }
29802
29803 }
29804
29805
29806 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorInteger_BaseType_get() {
29807   int jresult ;
29808   int result;
29809
29810   result = (int)Dali::Vector< int >::BaseType;
29811   jresult = (int)result;
29812   return jresult;
29813 }
29814
29815
29816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_0() {
29817   void * jresult ;
29818   Dali::Vector< int > *result = 0 ;
29819
29820   {
29821     try {
29822       result = (Dali::Vector< int > *)new Dali::Vector< int >();
29823     } CALL_CATCH_EXCEPTION(0);
29824   }
29825
29826   jresult = (void *)result;
29827   return jresult;
29828 }
29829
29830
29831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorInteger(void * jarg1) {
29832   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
29833
29834   arg1 = (Dali::Vector< int > *)jarg1;
29835   {
29836     try {
29837       delete arg1;
29838     } CALL_CATCH_EXCEPTION();
29839   }
29840
29841 }
29842
29843
29844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_1(void * jarg1) {
29845   void * jresult ;
29846   Dali::Vector< int > *arg1 = 0 ;
29847   Dali::Vector< int > *result = 0 ;
29848
29849   arg1 = (Dali::Vector< int > *)jarg1;
29850   if (!arg1) {
29851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
29852     return 0;
29853   }
29854   {
29855     try {
29856       result = (Dali::Vector< int > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1);
29857     } CALL_CATCH_EXCEPTION(0);
29858   }
29859
29860   jresult = (void *)result;
29861   return jresult;
29862 }
29863
29864
29865 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Assign(void * jarg1, void * jarg2) {
29866   void * jresult ;
29867   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
29868   Dali::Vector< int > *arg2 = 0 ;
29869   Dali::Vector< int > *result = 0 ;
29870
29871   arg1 = (Dali::Vector< int > *)jarg1;
29872   arg2 = (Dali::Vector< int > *)jarg2;
29873   if (!arg2) {
29874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
29875     return 0;
29876   }
29877   {
29878     try {
29879       result = (Dali::Vector< int > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2);
29880     } CALL_CATCH_EXCEPTION(0);
29881   }
29882
29883   jresult = (void *)result;
29884   return jresult;
29885 }
29886
29887
29888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Begin(void * jarg1) {
29889   void * jresult ;
29890   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
29891   Dali::Vector< int >::Iterator result;
29892
29893   arg1 = (Dali::Vector< int > *)jarg1;
29894   {
29895     try {
29896       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin();
29897     } CALL_CATCH_EXCEPTION(0);
29898   }
29899
29900   jresult = (void *)result;
29901   return jresult;
29902 }
29903
29904
29905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_End(void * jarg1) {
29906   void * jresult ;
29907   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
29908   Dali::Vector< int >::Iterator result;
29909
29910   arg1 = (Dali::Vector< int > *)jarg1;
29911   {
29912     try {
29913       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->End();
29914     } CALL_CATCH_EXCEPTION(0);
29915   }
29916
29917   jresult = (void *)result;
29918   return jresult;
29919 }
29920
29921
29922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
29923   void * jresult ;
29924   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
29925   Dali::Vector< int >::SizeType arg2 ;
29926   Dali::Vector< int >::ItemType *result = 0 ;
29927
29928   arg1 = (Dali::Vector< int > *)jarg1;
29929   arg2 = (Dali::Vector< int >::SizeType)jarg2;
29930   {
29931     try {
29932       result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2);
29933     } CALL_CATCH_EXCEPTION(0);
29934   }
29935
29936   jresult = (void *)result;
29937   return jresult;
29938 }
29939
29940
29941 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_PushBack(void * jarg1, int jarg2) {
29942   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
29943   Dali::Vector< int >::ItemType *arg2 = 0 ;
29944   Dali::Vector< int >::ItemType temp2 ;
29945
29946   arg1 = (Dali::Vector< int > *)jarg1;
29947   temp2 = (Dali::Vector< int >::ItemType)jarg2;
29948   arg2 = &temp2;
29949   {
29950     try {
29951       (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2);
29952     } CALL_CATCH_EXCEPTION();
29953   }
29954
29955 }
29956
29957
29958 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
29959   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
29960   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
29961   Dali::Vector< int >::ItemType *arg3 = 0 ;
29962   Dali::Vector< int >::ItemType temp3 ;
29963
29964   arg1 = (Dali::Vector< int > *)jarg1;
29965   arg2 = (Dali::Vector< int >::Iterator)jarg2;
29966   temp3 = (Dali::Vector< int >::ItemType)jarg3;
29967   arg3 = &temp3;
29968   {
29969     try {
29970       (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
29971     } CALL_CATCH_EXCEPTION();
29972   }
29973
29974 }
29975
29976
29977 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
29978   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
29979   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
29980   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
29981   Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ;
29982
29983   arg1 = (Dali::Vector< int > *)jarg1;
29984   arg2 = (Dali::Vector< int >::Iterator)jarg2;
29985   arg3 = (Dali::Vector< int >::Iterator)jarg3;
29986   arg4 = (Dali::Vector< int >::Iterator)jarg4;
29987   {
29988     try {
29989       (arg1)->Insert(arg2,arg3,arg4);
29990     } CALL_CATCH_EXCEPTION();
29991   }
29992
29993 }
29994
29995
29996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) {
29997   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
29998   Dali::Vector< int >::SizeType arg2 ;
29999
30000   arg1 = (Dali::Vector< int > *)jarg1;
30001   arg2 = (Dali::Vector< int >::SizeType)jarg2;
30002   {
30003     try {
30004       (arg1)->Reserve(arg2);
30005     } CALL_CATCH_EXCEPTION();
30006   }
30007
30008 }
30009
30010
30011 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
30012   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
30013   Dali::Vector< int >::SizeType arg2 ;
30014
30015   arg1 = (Dali::Vector< int > *)jarg1;
30016   arg2 = (Dali::Vector< int >::SizeType)jarg2;
30017   {
30018     try {
30019       (arg1)->Resize(arg2);
30020     } CALL_CATCH_EXCEPTION();
30021   }
30022
30023 }
30024
30025
30026 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) {
30027   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
30028   Dali::Vector< int >::SizeType arg2 ;
30029   Dali::Vector< int >::ItemType *arg3 = 0 ;
30030   Dali::Vector< int >::ItemType temp3 ;
30031
30032   arg1 = (Dali::Vector< int > *)jarg1;
30033   arg2 = (Dali::Vector< int >::SizeType)jarg2;
30034   temp3 = (Dali::Vector< int >::ItemType)jarg3;
30035   arg3 = &temp3;
30036   {
30037     try {
30038       (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
30039     } CALL_CATCH_EXCEPTION();
30040   }
30041
30042 }
30043
30044
30045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) {
30046   void * jresult ;
30047   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
30048   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
30049   Dali::Vector< int >::Iterator result;
30050
30051   arg1 = (Dali::Vector< int > *)jarg1;
30052   arg2 = (Dali::Vector< int >::Iterator)jarg2;
30053   {
30054     try {
30055       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2);
30056     } CALL_CATCH_EXCEPTION(0);
30057   }
30058
30059   jresult = (void *)result;
30060   return jresult;
30061 }
30062
30063
30064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
30065   void * jresult ;
30066   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
30067   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
30068   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
30069   Dali::Vector< int >::Iterator result;
30070
30071   arg1 = (Dali::Vector< int > *)jarg1;
30072   arg2 = (Dali::Vector< int >::Iterator)jarg2;
30073   arg3 = (Dali::Vector< int >::Iterator)jarg3;
30074   {
30075     try {
30076       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3);
30077     } CALL_CATCH_EXCEPTION(0);
30078   }
30079
30080   jresult = (void *)result;
30081   return jresult;
30082 }
30083
30084
30085 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Remove(void * jarg1, void * jarg2) {
30086   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
30087   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
30088
30089   arg1 = (Dali::Vector< int > *)jarg1;
30090   arg2 = (Dali::Vector< int >::Iterator)jarg2;
30091   {
30092     try {
30093       (arg1)->Remove(arg2);
30094     } CALL_CATCH_EXCEPTION();
30095   }
30096
30097 }
30098
30099
30100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Swap(void * jarg1, void * jarg2) {
30101   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
30102   Dali::Vector< int > *arg2 = 0 ;
30103
30104   arg1 = (Dali::Vector< int > *)jarg1;
30105   arg2 = (Dali::Vector< int > *)jarg2;
30106   if (!arg2) {
30107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0);
30108     return ;
30109   }
30110   {
30111     try {
30112       (arg1)->Swap(*arg2);
30113     } CALL_CATCH_EXCEPTION();
30114   }
30115
30116 }
30117
30118
30119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Clear(void * jarg1) {
30120   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
30121
30122   arg1 = (Dali::Vector< int > *)jarg1;
30123   {
30124     try {
30125       (arg1)->Clear();
30126     } CALL_CATCH_EXCEPTION();
30127   }
30128
30129 }
30130
30131
30132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Release(void * jarg1) {
30133   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
30134
30135   arg1 = (Dali::Vector< int > *)jarg1;
30136   {
30137     try {
30138       (arg1)->Release();
30139     } CALL_CATCH_EXCEPTION();
30140   }
30141
30142 }
30143
30144
30145 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorFloat_BaseType_get() {
30146   int jresult ;
30147   int result;
30148
30149   result = (int)Dali::Vector< float >::BaseType;
30150   jresult = (int)result;
30151   return jresult;
30152 }
30153
30154
30155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_0() {
30156   void * jresult ;
30157   Dali::Vector< float > *result = 0 ;
30158
30159   {
30160     try {
30161       result = (Dali::Vector< float > *)new Dali::Vector< float >();
30162     } CALL_CATCH_EXCEPTION(0);
30163   }
30164
30165   jresult = (void *)result;
30166   return jresult;
30167 }
30168
30169
30170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorFloat(void * jarg1) {
30171   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30172
30173   arg1 = (Dali::Vector< float > *)jarg1;
30174   {
30175     try {
30176       delete arg1;
30177     } CALL_CATCH_EXCEPTION();
30178   }
30179
30180 }
30181
30182
30183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_1(void * jarg1) {
30184   void * jresult ;
30185   Dali::Vector< float > *arg1 = 0 ;
30186   Dali::Vector< float > *result = 0 ;
30187
30188   arg1 = (Dali::Vector< float > *)jarg1;
30189   if (!arg1) {
30190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
30191     return 0;
30192   }
30193   {
30194     try {
30195       result = (Dali::Vector< float > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1);
30196     } CALL_CATCH_EXCEPTION(0);
30197   }
30198
30199   jresult = (void *)result;
30200   return jresult;
30201 }
30202
30203
30204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Assign(void * jarg1, void * jarg2) {
30205   void * jresult ;
30206   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30207   Dali::Vector< float > *arg2 = 0 ;
30208   Dali::Vector< float > *result = 0 ;
30209
30210   arg1 = (Dali::Vector< float > *)jarg1;
30211   arg2 = (Dali::Vector< float > *)jarg2;
30212   if (!arg2) {
30213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
30214     return 0;
30215   }
30216   {
30217     try {
30218       result = (Dali::Vector< float > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2);
30219     } CALL_CATCH_EXCEPTION(0);
30220   }
30221
30222   jresult = (void *)result;
30223   return jresult;
30224 }
30225
30226
30227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Begin(void * jarg1) {
30228   void * jresult ;
30229   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30230   Dali::Vector< float >::Iterator result;
30231
30232   arg1 = (Dali::Vector< float > *)jarg1;
30233   {
30234     try {
30235       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin();
30236     } CALL_CATCH_EXCEPTION(0);
30237   }
30238
30239   jresult = (void *)result;
30240   return jresult;
30241 }
30242
30243
30244 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_End(void * jarg1) {
30245   void * jresult ;
30246   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30247   Dali::Vector< float >::Iterator result;
30248
30249   arg1 = (Dali::Vector< float > *)jarg1;
30250   {
30251     try {
30252       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->End();
30253     } CALL_CATCH_EXCEPTION(0);
30254   }
30255
30256   jresult = (void *)result;
30257   return jresult;
30258 }
30259
30260
30261 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
30262   void * jresult ;
30263   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30264   Dali::Vector< float >::SizeType arg2 ;
30265   Dali::Vector< float >::ItemType *result = 0 ;
30266
30267   arg1 = (Dali::Vector< float > *)jarg1;
30268   arg2 = (Dali::Vector< float >::SizeType)jarg2;
30269   {
30270     try {
30271       result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2);
30272     } CALL_CATCH_EXCEPTION(0);
30273   }
30274
30275   jresult = (void *)result;
30276   return jresult;
30277 }
30278
30279
30280 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_PushBack(void * jarg1, float jarg2) {
30281   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30282   Dali::Vector< float >::ItemType *arg2 = 0 ;
30283   Dali::Vector< float >::ItemType temp2 ;
30284
30285   arg1 = (Dali::Vector< float > *)jarg1;
30286   temp2 = (Dali::Vector< float >::ItemType)jarg2;
30287   arg2 = &temp2;
30288   {
30289     try {
30290       (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2);
30291     } CALL_CATCH_EXCEPTION();
30292   }
30293
30294 }
30295
30296
30297 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) {
30298   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30299   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
30300   Dali::Vector< float >::ItemType *arg3 = 0 ;
30301   Dali::Vector< float >::ItemType temp3 ;
30302
30303   arg1 = (Dali::Vector< float > *)jarg1;
30304   arg2 = (Dali::Vector< float >::Iterator)jarg2;
30305   temp3 = (Dali::Vector< float >::ItemType)jarg3;
30306   arg3 = &temp3;
30307   {
30308     try {
30309       (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
30310     } CALL_CATCH_EXCEPTION();
30311   }
30312
30313 }
30314
30315
30316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
30317   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30318   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
30319   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
30320   Dali::Vector< float >::Iterator arg4 = (Dali::Vector< float >::Iterator) 0 ;
30321
30322   arg1 = (Dali::Vector< float > *)jarg1;
30323   arg2 = (Dali::Vector< float >::Iterator)jarg2;
30324   arg3 = (Dali::Vector< float >::Iterator)jarg3;
30325   arg4 = (Dali::Vector< float >::Iterator)jarg4;
30326   {
30327     try {
30328       (arg1)->Insert(arg2,arg3,arg4);
30329     } CALL_CATCH_EXCEPTION();
30330   }
30331
30332 }
30333
30334
30335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) {
30336   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30337   Dali::Vector< float >::SizeType arg2 ;
30338
30339   arg1 = (Dali::Vector< float > *)jarg1;
30340   arg2 = (Dali::Vector< float >::SizeType)jarg2;
30341   {
30342     try {
30343       (arg1)->Reserve(arg2);
30344     } CALL_CATCH_EXCEPTION();
30345   }
30346
30347 }
30348
30349 //// ========================= end of part 2 =============================
30350
30351 //// ========================== start part 3 ===============================
30352
30353
30354 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
30355   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30356   Dali::Vector< float >::SizeType arg2 ;
30357
30358   arg1 = (Dali::Vector< float > *)jarg1;
30359   arg2 = (Dali::Vector< float >::SizeType)jarg2;
30360   {
30361     try {
30362       (arg1)->Resize(arg2);
30363     } CALL_CATCH_EXCEPTION();
30364   }
30365
30366 }
30367
30368
30369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) {
30370   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30371   Dali::Vector< float >::SizeType arg2 ;
30372   Dali::Vector< float >::ItemType *arg3 = 0 ;
30373   Dali::Vector< float >::ItemType temp3 ;
30374
30375   arg1 = (Dali::Vector< float > *)jarg1;
30376   arg2 = (Dali::Vector< float >::SizeType)jarg2;
30377   temp3 = (Dali::Vector< float >::ItemType)jarg3;
30378   arg3 = &temp3;
30379   {
30380     try {
30381       (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
30382     } CALL_CATCH_EXCEPTION();
30383   }
30384
30385 }
30386
30387
30388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) {
30389   void * jresult ;
30390   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30391   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
30392   Dali::Vector< float >::Iterator result;
30393
30394   arg1 = (Dali::Vector< float > *)jarg1;
30395   arg2 = (Dali::Vector< float >::Iterator)jarg2;
30396   {
30397     try {
30398       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2);
30399     } CALL_CATCH_EXCEPTION(0);
30400   }
30401
30402   jresult = (void *)result;
30403   return jresult;
30404 }
30405
30406
30407 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
30408   void * jresult ;
30409   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30410   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
30411   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
30412   Dali::Vector< float >::Iterator result;
30413
30414   arg1 = (Dali::Vector< float > *)jarg1;
30415   arg2 = (Dali::Vector< float >::Iterator)jarg2;
30416   arg3 = (Dali::Vector< float >::Iterator)jarg3;
30417   {
30418     try {
30419       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3);
30420     } CALL_CATCH_EXCEPTION(0);
30421   }
30422
30423   jresult = (void *)result;
30424   return jresult;
30425 }
30426
30427
30428 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Remove(void * jarg1, void * jarg2) {
30429   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30430   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
30431
30432   arg1 = (Dali::Vector< float > *)jarg1;
30433   arg2 = (Dali::Vector< float >::Iterator)jarg2;
30434   {
30435     try {
30436       (arg1)->Remove(arg2);
30437     } CALL_CATCH_EXCEPTION();
30438   }
30439
30440 }
30441
30442
30443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Swap(void * jarg1, void * jarg2) {
30444   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30445   Dali::Vector< float > *arg2 = 0 ;
30446
30447   arg1 = (Dali::Vector< float > *)jarg1;
30448   arg2 = (Dali::Vector< float > *)jarg2;
30449   if (!arg2) {
30450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0);
30451     return ;
30452   }
30453   {
30454     try {
30455       (arg1)->Swap(*arg2);
30456     } CALL_CATCH_EXCEPTION();
30457   }
30458
30459 }
30460
30461
30462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Clear(void * jarg1) {
30463   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30464
30465   arg1 = (Dali::Vector< float > *)jarg1;
30466   {
30467     try {
30468       (arg1)->Clear();
30469     } CALL_CATCH_EXCEPTION();
30470   }
30471
30472 }
30473
30474
30475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Release(void * jarg1) {
30476   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30477
30478   arg1 = (Dali::Vector< float > *)jarg1;
30479   {
30480     try {
30481       (arg1)->Release();
30482     } CALL_CATCH_EXCEPTION();
30483   }
30484
30485 }
30486
30487
30488 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_BaseType_get() {
30489   int jresult ;
30490   int result;
30491
30492   result = (int)Dali::Vector< unsigned char >::BaseType;
30493   jresult = (int)result;
30494   return jresult;
30495 }
30496
30497
30498 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_0() {
30499   void * jresult ;
30500   Dali::Vector< unsigned char > *result = 0 ;
30501
30502   {
30503     try {
30504       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >();
30505     } CALL_CATCH_EXCEPTION(0);
30506   }
30507
30508   jresult = (void *)result;
30509   return jresult;
30510 }
30511
30512
30513 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUnsignedChar(void * jarg1) {
30514   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30515
30516   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30517   {
30518     try {
30519       delete arg1;
30520     } CALL_CATCH_EXCEPTION();
30521   }
30522
30523 }
30524
30525
30526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_1(void * jarg1) {
30527   void * jresult ;
30528   Dali::Vector< unsigned char > *arg1 = 0 ;
30529   Dali::Vector< unsigned char > *result = 0 ;
30530
30531   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30532   if (!arg1) {
30533     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
30534     return 0;
30535   }
30536   {
30537     try {
30538       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > const &)*arg1);
30539     } CALL_CATCH_EXCEPTION(0);
30540   }
30541
30542   jresult = (void *)result;
30543   return jresult;
30544 }
30545
30546
30547 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Assign(void * jarg1, void * jarg2) {
30548   void * jresult ;
30549   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30550   Dali::Vector< unsigned char > *arg2 = 0 ;
30551   Dali::Vector< unsigned char > *result = 0 ;
30552
30553   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30554   arg2 = (Dali::Vector< unsigned char > *)jarg2;
30555   if (!arg2) {
30556     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
30557     return 0;
30558   }
30559   {
30560     try {
30561       result = (Dali::Vector< unsigned char > *) &(arg1)->operator =((Dali::Vector< unsigned char > const &)*arg2);
30562     } CALL_CATCH_EXCEPTION(0);
30563   }
30564
30565   jresult = (void *)result;
30566   return jresult;
30567 }
30568
30569
30570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Begin(void * jarg1) {
30571   void * jresult ;
30572   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30573   Dali::Vector< unsigned char >::Iterator result;
30574
30575   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30576   {
30577     try {
30578       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin();
30579     } CALL_CATCH_EXCEPTION(0);
30580   }
30581
30582   jresult = (void *)result;
30583   return jresult;
30584 }
30585
30586
30587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_End(void * jarg1) {
30588   void * jresult ;
30589   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30590   Dali::Vector< unsigned char >::Iterator result;
30591
30592   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30593   {
30594     try {
30595       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->End();
30596     } CALL_CATCH_EXCEPTION(0);
30597   }
30598
30599   jresult = (void *)result;
30600   return jresult;
30601 }
30602
30603
30604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
30605   void * jresult ;
30606   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30607   Dali::Vector< unsigned char >::SizeType arg2 ;
30608   Dali::Vector< unsigned char >::ItemType *result = 0 ;
30609
30610   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30611   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
30612   {
30613     try {
30614       result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2);
30615     } CALL_CATCH_EXCEPTION(0);
30616   }
30617
30618   jresult = (void *)result;
30619   return jresult;
30620 }
30621
30622
30623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) {
30624   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30625   Dali::Vector< unsigned char >::ItemType *arg2 = 0 ;
30626   Dali::Vector< unsigned char >::ItemType temp2 ;
30627
30628   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30629   temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2;
30630   arg2 = &temp2;
30631   {
30632     try {
30633       (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2);
30634     } CALL_CATCH_EXCEPTION();
30635   }
30636
30637 }
30638
30639
30640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) {
30641   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30642   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
30643   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
30644   Dali::Vector< unsigned char >::ItemType temp3 ;
30645
30646   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30647   arg2 = jarg2;
30648   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
30649   arg3 = &temp3;
30650   {
30651     try {
30652       (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
30653     } CALL_CATCH_EXCEPTION();
30654   }
30655
30656
30657
30658 }
30659
30660
30661 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) {
30662   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30663   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
30664   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
30665   Dali::Vector< unsigned char >::Iterator arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ;
30666
30667   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30668   arg2 = jarg2;
30669   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
30670   arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4;
30671   {
30672     try {
30673       (arg1)->Insert(arg2,arg3,arg4);
30674     } CALL_CATCH_EXCEPTION();
30675   }
30676
30677
30678
30679 }
30680
30681
30682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Reserve(void * jarg1, unsigned long jarg2) {
30683   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30684   Dali::Vector< unsigned char >::SizeType arg2 ;
30685
30686   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30687   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
30688   {
30689     try {
30690       (arg1)->Reserve(arg2);
30691     } CALL_CATCH_EXCEPTION();
30692   }
30693
30694 }
30695
30696
30697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
30698   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30699   Dali::Vector< unsigned char >::SizeType arg2 ;
30700
30701   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30702   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
30703   {
30704     try {
30705       (arg1)->Resize(arg2);
30706     } CALL_CATCH_EXCEPTION();
30707   }
30708
30709 }
30710
30711
30712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) {
30713   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30714   Dali::Vector< unsigned char >::SizeType arg2 ;
30715   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
30716   Dali::Vector< unsigned char >::ItemType temp3 ;
30717
30718   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30719   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
30720   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
30721   arg3 = &temp3;
30722   {
30723     try {
30724       (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
30725     } CALL_CATCH_EXCEPTION();
30726   }
30727
30728 }
30729
30730
30731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) {
30732   void * jresult ;
30733   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30734   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
30735   Dali::Vector< unsigned char >::Iterator result;
30736
30737   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30738   arg2 = jarg2;
30739   {
30740     try {
30741       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2);
30742     } CALL_CATCH_EXCEPTION(0);
30743   }
30744
30745   jresult = (void *)result;
30746
30747
30748   return jresult;
30749 }
30750
30751
30752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) {
30753   void * jresult ;
30754   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30755   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
30756   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
30757   Dali::Vector< unsigned char >::Iterator result;
30758
30759   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30760   arg2 = jarg2;
30761   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
30762   {
30763     try {
30764       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3);
30765     } CALL_CATCH_EXCEPTION(0);
30766   }
30767
30768   jresult = (void *)result;
30769
30770
30771   return jresult;
30772 }
30773
30774
30775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Remove(void * jarg1, unsigned char* jarg2) {
30776   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30777   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
30778
30779   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30780   arg2 = jarg2;
30781   {
30782     try {
30783       (arg1)->Remove(arg2);
30784     } CALL_CATCH_EXCEPTION();
30785   }
30786
30787
30788
30789 }
30790
30791
30792 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) {
30793   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30794   Dali::Vector< unsigned char > *arg2 = 0 ;
30795
30796   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30797   arg2 = (Dali::Vector< unsigned char > *)jarg2;
30798   if (!arg2) {
30799     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0);
30800     return ;
30801   }
30802   {
30803     try {
30804       (arg1)->Swap(*arg2);
30805     } CALL_CATCH_EXCEPTION();
30806   }
30807
30808 }
30809
30810
30811 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Clear(void * jarg1) {
30812   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30813
30814   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30815   {
30816     try {
30817       (arg1)->Clear();
30818     } CALL_CATCH_EXCEPTION();
30819   }
30820
30821 }
30822
30823
30824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Release(void * jarg1) {
30825   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30826
30827   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30828   {
30829     try {
30830       (arg1)->Release();
30831     } CALL_CATCH_EXCEPTION();
30832   }
30833
30834 }
30835
30836
30837 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUint16Pair_BaseType_get() {
30838   int jresult ;
30839   int result;
30840
30841   result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType;
30842   jresult = (int)result;
30843   return jresult;
30844 }
30845
30846
30847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_0() {
30848   void * jresult ;
30849   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
30850
30851   {
30852     try {
30853       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >();
30854     } CALL_CATCH_EXCEPTION(0);
30855   }
30856
30857   jresult = (void *)result;
30858   return jresult;
30859 }
30860
30861
30862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUint16Pair(void * jarg1) {
30863   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
30864
30865   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
30866   {
30867     try {
30868       delete arg1;
30869     } CALL_CATCH_EXCEPTION();
30870   }
30871
30872 }
30873
30874
30875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_1(void * jarg1) {
30876   void * jresult ;
30877   Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ;
30878   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
30879
30880   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
30881   if (!arg1) {
30882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
30883     return 0;
30884   }
30885   {
30886     try {
30887       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1);
30888     } CALL_CATCH_EXCEPTION(0);
30889   }
30890
30891   jresult = (void *)result;
30892   return jresult;
30893 }
30894
30895
30896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Assign(void * jarg1, void * jarg2) {
30897   void * jresult ;
30898   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
30899   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
30900   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
30901
30902   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
30903   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
30904   if (!arg2) {
30905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
30906     return 0;
30907   }
30908   {
30909     try {
30910       result = (Dali::Vector< Dali::Uint16Pair > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2);
30911     } CALL_CATCH_EXCEPTION(0);
30912   }
30913
30914   jresult = (void *)result;
30915   return jresult;
30916 }
30917
30918
30919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Begin(void * jarg1) {
30920   void * jresult ;
30921   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
30922   Dali::Vector< Dali::Uint16Pair >::Iterator result;
30923
30924   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
30925   {
30926     try {
30927       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin();
30928     } CALL_CATCH_EXCEPTION(0);
30929   }
30930
30931   jresult = (void *)result;
30932   return jresult;
30933 }
30934
30935
30936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_End(void * jarg1) {
30937   void * jresult ;
30938   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
30939   Dali::Vector< Dali::Uint16Pair >::Iterator result;
30940
30941   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
30942   {
30943     try {
30944       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->End();
30945     } CALL_CATCH_EXCEPTION(0);
30946   }
30947
30948   jresult = (void *)result;
30949   return jresult;
30950 }
30951
30952
30953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
30954   void * jresult ;
30955   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
30956   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
30957   Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ;
30958
30959   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
30960   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
30961   {
30962     try {
30963       result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2);
30964     } CALL_CATCH_EXCEPTION(0);
30965   }
30966
30967   jresult = (void *)result;
30968   return jresult;
30969 }
30970
30971
30972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) {
30973   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
30974   Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ;
30975
30976   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
30977   arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2;
30978   if (!arg2) {
30979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
30980     return ;
30981   }
30982   {
30983     try {
30984       (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2);
30985     } CALL_CATCH_EXCEPTION();
30986   }
30987
30988 }
30989
30990
30991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
30992   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
30993   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
30994   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
30995
30996   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
30997   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
30998   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
30999   if (!arg3) {
31000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
31001     return ;
31002   }
31003   {
31004     try {
31005       (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
31006     } CALL_CATCH_EXCEPTION();
31007   }
31008
31009 }
31010
31011
31012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
31013   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
31014   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
31015   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
31016   Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
31017
31018   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
31019   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
31020   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
31021   arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4;
31022   {
31023     try {
31024       (arg1)->Insert(arg2,arg3,arg4);
31025     } CALL_CATCH_EXCEPTION();
31026   }
31027
31028 }
31029
31030
31031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) {
31032   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
31033   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
31034
31035   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
31036   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
31037   {
31038     try {
31039       (arg1)->Reserve(arg2);
31040     } CALL_CATCH_EXCEPTION();
31041   }
31042
31043 }
31044
31045
31046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
31047   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
31048   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
31049
31050   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
31051   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
31052   {
31053     try {
31054       (arg1)->Resize(arg2);
31055     } CALL_CATCH_EXCEPTION();
31056   }
31057
31058 }
31059
31060
31061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
31062   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
31063   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
31064   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
31065
31066   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
31067   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
31068   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
31069   if (!arg3) {
31070     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
31071     return ;
31072   }
31073   {
31074     try {
31075       (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
31076     } CALL_CATCH_EXCEPTION();
31077   }
31078
31079 }
31080
31081
31082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_0(void * jarg1, void * jarg2) {
31083   void * jresult ;
31084   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
31085   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
31086   Dali::Vector< Dali::Uint16Pair >::Iterator result;
31087
31088   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
31089   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
31090   {
31091     try {
31092       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2);
31093     } CALL_CATCH_EXCEPTION(0);
31094   }
31095
31096   jresult = (void *)result;
31097   return jresult;
31098 }
31099
31100
31101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
31102   void * jresult ;
31103   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
31104   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
31105   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
31106   Dali::Vector< Dali::Uint16Pair >::Iterator result;
31107
31108   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
31109   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
31110   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
31111   {
31112     try {
31113       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3);
31114     } CALL_CATCH_EXCEPTION(0);
31115   }
31116
31117   jresult = (void *)result;
31118   return jresult;
31119 }
31120
31121
31122 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Remove(void * jarg1, void * jarg2) {
31123   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
31124   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
31125
31126   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
31127   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
31128   {
31129     try {
31130       (arg1)->Remove(arg2);
31131     } CALL_CATCH_EXCEPTION();
31132   }
31133
31134 }
31135
31136
31137 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Swap(void * jarg1, void * jarg2) {
31138   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
31139   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
31140
31141   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
31142   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
31143   if (!arg2) {
31144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0);
31145     return ;
31146   }
31147   {
31148     try {
31149       (arg1)->Swap(*arg2);
31150     } CALL_CATCH_EXCEPTION();
31151   }
31152
31153 }
31154
31155
31156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Clear(void * jarg1) {
31157   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
31158
31159   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
31160   {
31161     try {
31162       (arg1)->Clear();
31163     } CALL_CATCH_EXCEPTION();
31164   }
31165
31166 }
31167
31168
31169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Release(void * jarg1) {
31170   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
31171
31172   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
31173   {
31174     try {
31175       (arg1)->Release();
31176     } CALL_CATCH_EXCEPTION();
31177   }
31178
31179 }
31180
31181
31182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignal() {
31183   void * jresult ;
31184   Dali::Signal< void () > *result = 0 ;
31185
31186   {
31187     try {
31188       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
31189     } CALL_CATCH_EXCEPTION(0);
31190   }
31191
31192   jresult = (void *)result;
31193   return jresult;
31194 }
31195
31196
31197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignal(void * jarg1) {
31198   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
31199
31200   arg1 = (Dali::Signal< void () > *)jarg1;
31201   {
31202     try {
31203       delete arg1;
31204     } CALL_CATCH_EXCEPTION();
31205   }
31206
31207 }
31208
31209
31210 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VoidSignal_Empty(void * jarg1) {
31211   unsigned int jresult ;
31212   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
31213   bool result;
31214
31215   arg1 = (Dali::Signal< void () > *)jarg1;
31216   {
31217     try {
31218       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
31219     } CALL_CATCH_EXCEPTION(0);
31220   }
31221
31222   jresult = result;
31223   return jresult;
31224 }
31225
31226
31227 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignal_GetConnectionCount(void * jarg1) {
31228   unsigned long jresult ;
31229   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
31230   std::size_t result;
31231
31232   arg1 = (Dali::Signal< void () > *)jarg1;
31233   {
31234     try {
31235       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
31236     } CALL_CATCH_EXCEPTION(0);
31237   }
31238
31239   jresult = (unsigned long)result;
31240   return jresult;
31241 }
31242
31243
31244 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
31245   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
31246   void (*arg2)() = (void (*)()) 0 ;
31247
31248   arg1 = (Dali::Signal< void () > *)jarg1;
31249   arg2 = (void (*)())jarg2;
31250   {
31251     try {
31252       (arg1)->Connect(arg2);
31253     } CALL_CATCH_EXCEPTION();
31254   }
31255
31256 }
31257
31258
31259 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Disconnect(void * jarg1, void * jarg2) {
31260   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
31261   void (*arg2)() = (void (*)()) 0 ;
31262
31263   arg1 = (Dali::Signal< void () > *)jarg1;
31264   arg2 = (void (*)())jarg2;
31265   {
31266     try {
31267       (arg1)->Disconnect(arg2);
31268     } CALL_CATCH_EXCEPTION();
31269   }
31270
31271 }
31272
31273
31274 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
31275   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
31276   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
31277   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
31278
31279   arg1 = (Dali::Signal< void () > *)jarg1;
31280   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
31281   arg3 = (Dali::FunctorDelegate *)jarg3;
31282   {
31283     try {
31284       (arg1)->Connect(arg2,arg3);
31285     } CALL_CATCH_EXCEPTION();
31286   }
31287
31288 }
31289
31290
31291 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Emit(void * jarg1) {
31292   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
31293
31294   arg1 = (Dali::Signal< void () > *)jarg1;
31295   {
31296     try {
31297       (arg1)->Emit();
31298     } CALL_CATCH_EXCEPTION();
31299   }
31300
31301 }
31302
31303
31304 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FloatSignal_Empty(void * jarg1) {
31305   unsigned int jresult ;
31306   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
31307   bool result;
31308
31309   arg1 = (Dali::Signal< void (float) > *)jarg1;
31310   {
31311     try {
31312       result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1);
31313     } CALL_CATCH_EXCEPTION(0);
31314   }
31315
31316   jresult = result;
31317   return jresult;
31318 }
31319
31320
31321 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FloatSignal_GetConnectionCount(void * jarg1) {
31322   unsigned long jresult ;
31323   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
31324   std::size_t result;
31325
31326   arg1 = (Dali::Signal< void (float) > *)jarg1;
31327   {
31328     try {
31329       result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1);
31330     } CALL_CATCH_EXCEPTION(0);
31331   }
31332
31333   jresult = (unsigned long)result;
31334   return jresult;
31335 }
31336
31337
31338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Connect(void * jarg1, void * jarg2) {
31339   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
31340   void (*arg2)(float) = (void (*)(float)) 0 ;
31341
31342   arg1 = (Dali::Signal< void (float) > *)jarg1;
31343   arg2 = (void (*)(float))jarg2;
31344   {
31345     try {
31346       Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2);
31347     } CALL_CATCH_EXCEPTION();
31348   }
31349
31350 }
31351
31352
31353 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Disconnect(void * jarg1, void * jarg2) {
31354   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
31355   void (*arg2)(float) = (void (*)(float)) 0 ;
31356
31357   arg1 = (Dali::Signal< void (float) > *)jarg1;
31358   arg2 = (void (*)(float))jarg2;
31359   {
31360     try {
31361       Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(arg1,arg2);
31362     } CALL_CATCH_EXCEPTION();
31363   }
31364
31365 }
31366
31367
31368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Emit(void * jarg1, float jarg2) {
31369   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
31370   float arg2 ;
31371
31372   arg1 = (Dali::Signal< void (float) > *)jarg1;
31373   arg2 = (float)jarg2;
31374   {
31375     try {
31376       Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(arg1,arg2);
31377     } CALL_CATCH_EXCEPTION();
31378   }
31379
31380 }
31381
31382
31383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FloatSignal() {
31384   void * jresult ;
31385   Dali::Signal< void (float) > *result = 0 ;
31386
31387   {
31388     try {
31389       result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >();
31390     } CALL_CATCH_EXCEPTION(0);
31391   }
31392
31393   jresult = (void *)result;
31394   return jresult;
31395 }
31396
31397
31398 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FloatSignal(void * jarg1) {
31399   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
31400
31401   arg1 = (Dali::Signal< void (float) > *)jarg1;
31402   {
31403     try {
31404       delete arg1;
31405     } CALL_CATCH_EXCEPTION();
31406   }
31407
31408 }
31409
31410
31411 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Empty(void * jarg1) {
31412   unsigned int jresult ;
31413   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
31414   bool result;
31415
31416   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
31417   {
31418     try {
31419       result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
31420     } CALL_CATCH_EXCEPTION(0);
31421   }
31422
31423   jresult = result;
31424   return jresult;
31425 }
31426
31427
31428 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_GetConnectionCount(void * jarg1) {
31429   unsigned long jresult ;
31430   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
31431   std::size_t result;
31432
31433   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
31434   {
31435     try {
31436       result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
31437     } CALL_CATCH_EXCEPTION(0);
31438   }
31439
31440   jresult = (unsigned long)result;
31441   return jresult;
31442 }
31443
31444
31445 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) {
31446   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
31447   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
31448
31449   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
31450   arg2 = (void (*)(Dali::BaseHandle))jarg2;
31451   {
31452     try {
31453       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2);
31454     } CALL_CATCH_EXCEPTION();
31455   }
31456
31457 }
31458
31459
31460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) {
31461   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
31462   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
31463
31464   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
31465   arg2 = (void (*)(Dali::BaseHandle))jarg2;
31466   {
31467     try {
31468       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2);
31469     } CALL_CATCH_EXCEPTION();
31470   }
31471
31472 }
31473
31474
31475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) {
31476   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
31477   Dali::BaseHandle arg2 ;
31478   Dali::BaseHandle *argp2 ;
31479
31480   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
31481   argp2 = (Dali::BaseHandle *)jarg2;
31482   if (!argp2) {
31483     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
31484     return ;
31485   }
31486   arg2 = *argp2;
31487   {
31488     try {
31489       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(arg1,arg2);
31490     } CALL_CATCH_EXCEPTION();
31491   }
31492
31493 }
31494
31495
31496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectCreatedSignal() {
31497   void * jresult ;
31498   Dali::Signal< void (Dali::BaseHandle) > *result = 0 ;
31499
31500   {
31501     try {
31502       result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >();
31503     } CALL_CATCH_EXCEPTION(0);
31504   }
31505
31506   jresult = (void *)result;
31507   return jresult;
31508 }
31509
31510
31511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectCreatedSignal(void * jarg1) {
31512   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
31513
31514   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
31515   {
31516     try {
31517       delete arg1;
31518     } CALL_CATCH_EXCEPTION();
31519   }
31520
31521 }
31522
31523
31524 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Empty(void * jarg1) {
31525   unsigned int jresult ;
31526   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
31527   bool result;
31528
31529   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
31530   {
31531     try {
31532       result = (bool)Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
31533     } CALL_CATCH_EXCEPTION(0);
31534   }
31535
31536   jresult = result;
31537   return jresult;
31538 }
31539
31540
31541 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_GetConnectionCount(void * jarg1) {
31542   unsigned long jresult ;
31543   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
31544   std::size_t result;
31545
31546   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
31547   {
31548     try {
31549       result = Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
31550     } CALL_CATCH_EXCEPTION(0);
31551   }
31552
31553   jresult = (unsigned long)result;
31554   return jresult;
31555 }
31556
31557
31558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Connect(void * jarg1, void * jarg2) {
31559   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
31560   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
31561
31562   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
31563   arg2 = (void (*)(Dali::RefObject const *))jarg2;
31564   {
31565     try {
31566       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(arg1,arg2);
31567     } CALL_CATCH_EXCEPTION();
31568   }
31569
31570 }
31571
31572
31573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Disconnect(void * jarg1, void * jarg2) {
31574   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
31575   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
31576
31577   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
31578   arg2 = (void (*)(Dali::RefObject const *))jarg2;
31579   {
31580     try {
31581       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(arg1,arg2);
31582     } CALL_CATCH_EXCEPTION();
31583   }
31584
31585 }
31586
31587
31588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Emit(void * jarg1, void * jarg2) {
31589   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
31590   Dali::RefObject *arg2 = (Dali::RefObject *) 0 ;
31591
31592   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
31593   arg2 = (Dali::RefObject *)jarg2;
31594   {
31595     try {
31596       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(arg1,(Dali::RefObject const *)arg2);
31597     } CALL_CATCH_EXCEPTION();
31598   }
31599
31600 }
31601
31602
31603 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectDestroyedSignal() {
31604   void * jresult ;
31605   Dali::Signal< void (Dali::RefObject const *) > *result = 0 ;
31606
31607   {
31608     try {
31609       result = (Dali::Signal< void (Dali::RefObject const *) > *)new Dali::Signal< void (Dali::RefObject const *) >();
31610     } CALL_CATCH_EXCEPTION(0);
31611   }
31612
31613   jresult = (void *)result;
31614   return jresult;
31615 }
31616
31617
31618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectDestroyedSignal(void * jarg1) {
31619   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
31620
31621   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
31622   {
31623     try {
31624       delete arg1;
31625     } CALL_CATCH_EXCEPTION();
31626   }
31627
31628 }
31629
31630
31631 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Empty(void * jarg1) {
31632   unsigned int jresult ;
31633   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
31634   bool result;
31635
31636   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
31637   {
31638     try {
31639       result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
31640     } CALL_CATCH_EXCEPTION(0);
31641   }
31642
31643   jresult = result;
31644   return jresult;
31645 }
31646
31647
31648 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_GetConnectionCount(void * jarg1) {
31649   unsigned long jresult ;
31650   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
31651   std::size_t result;
31652
31653   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
31654   {
31655     try {
31656       result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
31657     } CALL_CATCH_EXCEPTION(0);
31658   }
31659
31660   jresult = (unsigned long)result;
31661   return jresult;
31662 }
31663
31664
31665 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) {
31666   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
31667   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
31668
31669   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
31670   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
31671   {
31672     try {
31673       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2);
31674     } CALL_CATCH_EXCEPTION();
31675   }
31676
31677 }
31678
31679
31680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) {
31681   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
31682   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
31683
31684   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
31685   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
31686   {
31687     try {
31688       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2);
31689     } CALL_CATCH_EXCEPTION();
31690   }
31691
31692 }
31693
31694
31695 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) {
31696   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
31697   Dali::PropertyNotification *arg2 = 0 ;
31698
31699   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
31700   arg2 = (Dali::PropertyNotification *)jarg2;
31701   if (!arg2) {
31702     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0);
31703     return ;
31704   }
31705   {
31706     try {
31707       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(arg1,*arg2);
31708     } CALL_CATCH_EXCEPTION();
31709   }
31710
31711 }
31712
31713
31714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotifySignal() {
31715   void * jresult ;
31716   Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ;
31717
31718   {
31719     try {
31720       result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >();
31721     } CALL_CATCH_EXCEPTION(0);
31722   }
31723
31724   jresult = (void *)result;
31725   return jresult;
31726 }
31727
31728
31729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotifySignal(void * jarg1) {
31730   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
31731
31732   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
31733   {
31734     try {
31735       delete arg1;
31736     } CALL_CATCH_EXCEPTION();
31737   }
31738
31739 }
31740
31741
31742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskSignal() {
31743   void * jresult ;
31744   Dali::Signal< void (Dali::RenderTask &) > *result = 0 ;
31745
31746   {
31747     try {
31748       result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >();
31749     } CALL_CATCH_EXCEPTION(0);
31750   }
31751
31752   jresult = (void *)result;
31753   return jresult;
31754 }
31755
31756
31757 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskSignal(void * jarg1) {
31758   Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ;
31759
31760   arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1;
31761   {
31762     try {
31763       delete arg1;
31764     } CALL_CATCH_EXCEPTION();
31765   }
31766
31767 }
31768
31769
31770 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Empty(void * jarg1) {
31771   unsigned int jresult ;
31772   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
31773   bool result;
31774
31775   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
31776   {
31777     try {
31778       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);
31779     } CALL_CATCH_EXCEPTION(0);
31780   }
31781
31782   jresult = result;
31783   return jresult;
31784 }
31785
31786
31787 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) {
31788   unsigned long jresult ;
31789   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
31790   std::size_t result;
31791
31792   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
31793   {
31794     try {
31795       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);
31796     } CALL_CATCH_EXCEPTION(0);
31797   }
31798
31799   jresult = (unsigned long)result;
31800   return jresult;
31801 }
31802
31803
31804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
31805   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
31806   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
31807
31808   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
31809   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
31810   {
31811     try {
31812       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
31813     } CALL_CATCH_EXCEPTION();
31814   }
31815
31816 }
31817
31818
31819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
31820   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
31821   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
31822
31823   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
31824   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
31825   {
31826     try {
31827       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
31828     } CALL_CATCH_EXCEPTION();
31829   }
31830
31831 }
31832
31833
31834 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
31835   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
31836   Dali::Actor arg2 ;
31837   Dali::LongPressGesture *arg3 = 0 ;
31838   Dali::Actor *argp2 ;
31839
31840   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
31841   argp2 = (Dali::Actor *)jarg2;
31842   if (!argp2) {
31843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
31844     return ;
31845   }
31846   arg2 = *argp2;
31847   arg3 = (Dali::LongPressGesture *)jarg3;
31848   if (!arg3) {
31849     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
31850     return ;
31851   }
31852   {
31853     try {
31854       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture const &)*arg3);
31855     } CALL_CATCH_EXCEPTION();
31856   }
31857
31858 }
31859
31860
31861 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetectedSignal() {
31862   void * jresult ;
31863   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ;
31864
31865   {
31866     try {
31867       result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >();
31868     } CALL_CATCH_EXCEPTION(0);
31869   }
31870
31871   jresult = (void *)result;
31872   return jresult;
31873 }
31874
31875
31876 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetectedSignal(void * jarg1) {
31877   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
31878
31879   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
31880   {
31881     try {
31882       delete arg1;
31883     } CALL_CATCH_EXCEPTION();
31884   }
31885
31886 }
31887
31888
31889 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Empty(void * jarg1) {
31890   unsigned int jresult ;
31891   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
31892   bool result;
31893
31894   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
31895   {
31896     try {
31897       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);
31898     } CALL_CATCH_EXCEPTION(0);
31899   }
31900
31901   jresult = result;
31902   return jresult;
31903 }
31904
31905
31906 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_GetConnectionCount(void * jarg1) {
31907   unsigned long jresult ;
31908   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
31909   std::size_t result;
31910
31911   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
31912   {
31913     try {
31914       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);
31915     } CALL_CATCH_EXCEPTION(0);
31916   }
31917
31918   jresult = (unsigned long)result;
31919   return jresult;
31920 }
31921
31922
31923 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Connect(void * jarg1, void * jarg2) {
31924   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
31925   bool (*arg2)(Dali::Actor,Dali::TouchEvent const &) = (bool (*)(Dali::Actor,Dali::TouchEvent const &)) 0 ;
31926
31927   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
31928   arg2 = (bool (*)(Dali::Actor,Dali::TouchEvent const &))jarg2;
31929   {
31930     try {
31931       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
31932     } CALL_CATCH_EXCEPTION();
31933   }
31934
31935 }
31936
31937
31938 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Disconnect(void * jarg1, void * jarg2) {
31939   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
31940   bool (*arg2)(Dali::Actor,Dali::TouchEvent const &) = (bool (*)(Dali::Actor,Dali::TouchEvent const &)) 0 ;
31941
31942   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
31943   arg2 = (bool (*)(Dali::Actor,Dali::TouchEvent const &))jarg2;
31944   {
31945     try {
31946       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
31947     } CALL_CATCH_EXCEPTION();
31948   }
31949
31950 }
31951
31952
31953 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
31954   unsigned int jresult ;
31955   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
31956   Dali::Actor arg2 ;
31957   Dali::TouchEvent *arg3 = 0 ;
31958   Dali::Actor *argp2 ;
31959   bool result;
31960
31961   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
31962   argp2 = (Dali::Actor *)jarg2;
31963   if (!argp2) {
31964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
31965     return 0;
31966   }
31967   arg2 = *argp2;
31968   arg3 = (Dali::TouchEvent *)jarg3;
31969   if (!arg3) {
31970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
31971     return 0;
31972   }
31973   {
31974     try {
31975       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TouchEvent const &)*arg3);
31976     } CALL_CATCH_EXCEPTION(0);
31977   }
31978
31979   jresult = result;
31980   return jresult;
31981 }
31982
31983
31984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorTouchDataSignal() {
31985   void * jresult ;
31986   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *result = 0 ;
31987
31988   {
31989     try {
31990       result = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) >();
31991     } CALL_CATCH_EXCEPTION(0);
31992   }
31993
31994   jresult = (void *)result;
31995   return jresult;
31996 }
31997
31998
31999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorTouchDataSignal(void * jarg1) {
32000   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
32001
32002   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
32003   {
32004     try {
32005       delete arg1;
32006     } CALL_CATCH_EXCEPTION();
32007   }
32008
32009 }
32010
32011
32012 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Empty(void * jarg1) {
32013   unsigned int jresult ;
32014   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
32015   bool result;
32016
32017   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
32018   {
32019     try {
32020       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);
32021     } CALL_CATCH_EXCEPTION(0);
32022   }
32023
32024   jresult = result;
32025   return jresult;
32026 }
32027
32028
32029 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorHoverSignal_GetConnectionCount(void * jarg1) {
32030   unsigned long jresult ;
32031   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
32032   std::size_t result;
32033
32034   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
32035   {
32036     try {
32037       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);
32038     } CALL_CATCH_EXCEPTION(0);
32039   }
32040
32041   jresult = (unsigned long)result;
32042   return jresult;
32043 }
32044
32045
32046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Connect(void * jarg1, void * jarg2) {
32047   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
32048   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
32049
32050   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
32051   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
32052   {
32053     try {
32054       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
32055     } CALL_CATCH_EXCEPTION();
32056   }
32057
32058 }
32059
32060
32061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Disconnect(void * jarg1, void * jarg2) {
32062   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
32063   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
32064
32065   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
32066   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
32067   {
32068     try {
32069       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
32070     } CALL_CATCH_EXCEPTION();
32071   }
32072
32073 }
32074
32075
32076 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
32077   unsigned int jresult ;
32078   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
32079   Dali::Actor arg2 ;
32080   Dali::HoverEvent *arg3 = 0 ;
32081   Dali::Actor *argp2 ;
32082   bool result;
32083
32084   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
32085   argp2 = (Dali::Actor *)jarg2;
32086   if (!argp2) {
32087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32088     return 0;
32089   }
32090   arg2 = *argp2;
32091   arg3 = (Dali::HoverEvent *)jarg3;
32092   if (!arg3) {
32093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
32094     return 0;
32095   }
32096   {
32097     try {
32098       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::HoverEvent const &)*arg3);
32099     } CALL_CATCH_EXCEPTION(0);
32100   }
32101
32102   jresult = result;
32103   return jresult;
32104 }
32105
32106
32107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorHoverSignal() {
32108   void * jresult ;
32109   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *result = 0 ;
32110
32111   {
32112     try {
32113       result = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) >();
32114     } CALL_CATCH_EXCEPTION(0);
32115   }
32116
32117   jresult = (void *)result;
32118   return jresult;
32119 }
32120
32121
32122 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorHoverSignal(void * jarg1) {
32123   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
32124
32125   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
32126   {
32127     try {
32128       delete arg1;
32129     } CALL_CATCH_EXCEPTION();
32130   }
32131
32132 }
32133
32134
32135 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Empty(void * jarg1) {
32136   unsigned int jresult ;
32137   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
32138   bool result;
32139
32140   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
32141   {
32142     try {
32143       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);
32144     } CALL_CATCH_EXCEPTION(0);
32145   }
32146
32147   jresult = result;
32148   return jresult;
32149 }
32150
32151
32152 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorWheelSignal_GetConnectionCount(void * jarg1) {
32153   unsigned long jresult ;
32154   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
32155   std::size_t result;
32156
32157   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
32158   {
32159     try {
32160       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);
32161     } CALL_CATCH_EXCEPTION(0);
32162   }
32163
32164   jresult = (unsigned long)result;
32165   return jresult;
32166 }
32167
32168
32169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Connect(void * jarg1, void * jarg2) {
32170   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
32171   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
32172
32173   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
32174   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
32175   {
32176     try {
32177       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
32178     } CALL_CATCH_EXCEPTION();
32179   }
32180
32181 }
32182
32183
32184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Disconnect(void * jarg1, void * jarg2) {
32185   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
32186   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
32187
32188   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
32189   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
32190   {
32191     try {
32192       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
32193     } CALL_CATCH_EXCEPTION();
32194   }
32195
32196 }
32197
32198
32199 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
32200   unsigned int jresult ;
32201   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
32202   Dali::Actor arg2 ;
32203   Dali::WheelEvent *arg3 = 0 ;
32204   Dali::Actor *argp2 ;
32205   bool result;
32206
32207   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
32208   argp2 = (Dali::Actor *)jarg2;
32209   if (!argp2) {
32210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32211     return 0;
32212   }
32213   arg2 = *argp2;
32214   arg3 = (Dali::WheelEvent *)jarg3;
32215   if (!arg3) {
32216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
32217     return 0;
32218   }
32219   {
32220     try {
32221       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::WheelEvent const &)*arg3);
32222     } CALL_CATCH_EXCEPTION(0);
32223   }
32224
32225   jresult = result;
32226   return jresult;
32227 }
32228
32229
32230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorWheelSignal() {
32231   void * jresult ;
32232   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *result = 0 ;
32233
32234   {
32235     try {
32236       result = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) >();
32237     } CALL_CATCH_EXCEPTION(0);
32238   }
32239
32240   jresult = (void *)result;
32241   return jresult;
32242 }
32243
32244
32245 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorWheelSignal(void * jarg1) {
32246   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
32247
32248   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
32249   {
32250     try {
32251       delete arg1;
32252     } CALL_CATCH_EXCEPTION();
32253   }
32254
32255 }
32256
32257
32258 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorSignal_Empty(void * jarg1) {
32259   unsigned int jresult ;
32260   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
32261   bool result;
32262
32263   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
32264   {
32265     try {
32266       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor) > const *)arg1);
32267     } CALL_CATCH_EXCEPTION(0);
32268   }
32269
32270   jresult = result;
32271   return jresult;
32272 }
32273
32274
32275 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorSignal_GetConnectionCount(void * jarg1) {
32276   unsigned long jresult ;
32277   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
32278   std::size_t result;
32279
32280   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
32281   {
32282     try {
32283       result = Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor) > const *)arg1);
32284     } CALL_CATCH_EXCEPTION(0);
32285   }
32286
32287   jresult = (unsigned long)result;
32288   return jresult;
32289 }
32290
32291
32292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Connect(void * jarg1, void * jarg2) {
32293   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
32294   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
32295
32296   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
32297   arg2 = (void (*)(Dali::Actor))jarg2;
32298   {
32299     try {
32300       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(arg1,arg2);
32301     } CALL_CATCH_EXCEPTION();
32302   }
32303
32304 }
32305
32306
32307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Disconnect(void * jarg1, void * jarg2) {
32308   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
32309   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
32310
32311   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
32312   arg2 = (void (*)(Dali::Actor))jarg2;
32313   {
32314     try {
32315       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
32316     } CALL_CATCH_EXCEPTION();
32317   }
32318
32319 }
32320
32321
32322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Emit(void * jarg1, void * jarg2) {
32323   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
32324   Dali::Actor arg2 ;
32325   Dali::Actor *argp2 ;
32326
32327   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
32328   argp2 = (Dali::Actor *)jarg2;
32329   if (!argp2) {
32330     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32331     return ;
32332   }
32333   arg2 = *argp2;
32334   {
32335     try {
32336       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(arg1,arg2);
32337     } CALL_CATCH_EXCEPTION();
32338   }
32339
32340 }
32341
32342
32343 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorSignal() {
32344   void * jresult ;
32345   Dali::Signal< void (Dali::Actor) > *result = 0 ;
32346
32347   {
32348     try {
32349       result = (Dali::Signal< void (Dali::Actor) > *)new Dali::Signal< void (Dali::Actor) >();
32350     } CALL_CATCH_EXCEPTION(0);
32351   }
32352
32353   jresult = (void *)result;
32354   return jresult;
32355 }
32356
32357
32358 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorSignal(void * jarg1) {
32359   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
32360
32361   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
32362   {
32363     try {
32364       delete arg1;
32365     } CALL_CATCH_EXCEPTION();
32366   }
32367
32368 }
32369
32370
32371 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyEventSignal_Empty(void * jarg1) {
32372   unsigned int jresult ;
32373   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
32374   bool result;
32375
32376   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
32377   {
32378     try {
32379       result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
32380     } CALL_CATCH_EXCEPTION(0);
32381   }
32382
32383   jresult = result;
32384   return jresult;
32385 }
32386
32387
32388 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyEventSignal_GetConnectionCount(void * jarg1) {
32389   unsigned long jresult ;
32390   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
32391   std::size_t result;
32392
32393   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
32394   {
32395     try {
32396       result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
32397     } CALL_CATCH_EXCEPTION(0);
32398   }
32399
32400   jresult = (unsigned long)result;
32401   return jresult;
32402 }
32403
32404
32405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Connect(void * jarg1, void * jarg2) {
32406   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
32407   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
32408
32409   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
32410   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
32411   {
32412     try {
32413       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
32414     } CALL_CATCH_EXCEPTION();
32415   }
32416
32417 }
32418
32419
32420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
32421   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
32422   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
32423
32424   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
32425   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
32426   {
32427     try {
32428       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
32429     } CALL_CATCH_EXCEPTION();
32430   }
32431
32432 }
32433
32434
32435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Emit(void * jarg1, void * jarg2) {
32436   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
32437   Dali::KeyEvent *arg2 = 0 ;
32438
32439   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
32440   arg2 = (Dali::KeyEvent *)jarg2;
32441   if (!arg2) {
32442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32443     return ;
32444   }
32445   {
32446     try {
32447       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*arg2);
32448     } CALL_CATCH_EXCEPTION();
32449   }
32450
32451 }
32452
32453
32454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyEventSignal() {
32455   void * jresult ;
32456   Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ;
32457
32458   {
32459     try {
32460       result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >();
32461     } CALL_CATCH_EXCEPTION(0);
32462   }
32463
32464   jresult = (void *)result;
32465   return jresult;
32466 }
32467
32468
32469 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyEventSignal(void * jarg1) {
32470   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
32471
32472   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
32473   {
32474     try {
32475       delete arg1;
32476     } CALL_CATCH_EXCEPTION();
32477   }
32478
32479 }
32480
32481
32482 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TouchSignal_Empty(void * jarg1) {
32483   unsigned int jresult ;
32484   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
32485   bool result;
32486
32487   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
32488   {
32489     try {
32490       result = (bool)Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::TouchEvent const &) > const *)arg1);
32491     } CALL_CATCH_EXCEPTION(0);
32492   }
32493
32494   jresult = result;
32495   return jresult;
32496 }
32497
32498
32499 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchSignal_GetConnectionCount(void * jarg1) {
32500   unsigned long jresult ;
32501   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
32502   std::size_t result;
32503
32504   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
32505   {
32506     try {
32507       result = Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::TouchEvent const &) > const *)arg1);
32508     } CALL_CATCH_EXCEPTION(0);
32509   }
32510
32511   jresult = (unsigned long)result;
32512   return jresult;
32513 }
32514
32515
32516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Connect(void * jarg1, void * jarg2) {
32517   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
32518   void (*arg2)(Dali::TouchEvent const &) = (void (*)(Dali::TouchEvent const &)) 0 ;
32519
32520   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
32521   arg2 = (void (*)(Dali::TouchEvent const &))jarg2;
32522   {
32523     try {
32524       Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
32525     } CALL_CATCH_EXCEPTION();
32526   }
32527
32528 }
32529
32530
32531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Disconnect(void * jarg1, void * jarg2) {
32532   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
32533   void (*arg2)(Dali::TouchEvent const &) = (void (*)(Dali::TouchEvent const &)) 0 ;
32534
32535   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
32536   arg2 = (void (*)(Dali::TouchEvent const &))jarg2;
32537   {
32538     try {
32539       Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
32540     } CALL_CATCH_EXCEPTION();
32541   }
32542
32543 }
32544
32545
32546 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Emit(void * jarg1, void * jarg2) {
32547   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
32548   Dali::TouchEvent *arg2 = 0 ;
32549
32550   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
32551   arg2 = (Dali::TouchEvent *)jarg2;
32552   if (!arg2) {
32553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
32554     return ;
32555   }
32556   {
32557     try {
32558       Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::TouchEvent const &)*arg2);
32559     } CALL_CATCH_EXCEPTION();
32560   }
32561
32562 }
32563
32564
32565 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchSignal() {
32566   void * jresult ;
32567   Dali::Signal< void (Dali::TouchEvent const &) > *result = 0 ;
32568
32569   {
32570     try {
32571       result = (Dali::Signal< void (Dali::TouchEvent const &) > *)new Dali::Signal< void (Dali::TouchEvent const &) >();
32572     } CALL_CATCH_EXCEPTION(0);
32573   }
32574
32575   jresult = (void *)result;
32576   return jresult;
32577 }
32578
32579
32580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchSignal(void * jarg1) {
32581   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
32582
32583   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
32584   {
32585     try {
32586       delete arg1;
32587     } CALL_CATCH_EXCEPTION();
32588   }
32589
32590 }
32591
32592
32593 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StageWheelSignal_Empty(void * jarg1) {
32594   unsigned int jresult ;
32595   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
32596   bool result;
32597
32598   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
32599   {
32600     try {
32601       result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
32602     } CALL_CATCH_EXCEPTION(0);
32603   }
32604
32605   jresult = result;
32606   return jresult;
32607 }
32608
32609
32610 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StageWheelSignal_GetConnectionCount(void * jarg1) {
32611   unsigned long jresult ;
32612   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
32613   std::size_t result;
32614
32615   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
32616   {
32617     try {
32618       result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
32619     } CALL_CATCH_EXCEPTION(0);
32620   }
32621
32622   jresult = (unsigned long)result;
32623   return jresult;
32624 }
32625
32626
32627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Connect(void * jarg1, void * jarg2) {
32628   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
32629   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
32630
32631   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
32632   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
32633   {
32634     try {
32635       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
32636     } CALL_CATCH_EXCEPTION();
32637   }
32638
32639 }
32640
32641
32642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Disconnect(void * jarg1, void * jarg2) {
32643   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
32644   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
32645
32646   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
32647   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
32648   {
32649     try {
32650       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
32651     } CALL_CATCH_EXCEPTION();
32652   }
32653
32654 }
32655
32656
32657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Emit(void * jarg1, void * jarg2) {
32658   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
32659   Dali::WheelEvent *arg2 = 0 ;
32660
32661   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
32662   arg2 = (Dali::WheelEvent *)jarg2;
32663   if (!arg2) {
32664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
32665     return ;
32666   }
32667   {
32668     try {
32669       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2);
32670     } CALL_CATCH_EXCEPTION();
32671   }
32672
32673 }
32674
32675
32676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StageWheelSignal() {
32677   void * jresult ;
32678   Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ;
32679
32680   {
32681     try {
32682       result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >();
32683     } CALL_CATCH_EXCEPTION(0);
32684   }
32685
32686   jresult = (void *)result;
32687   return jresult;
32688 }
32689
32690
32691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StageWheelSignal(void * jarg1) {
32692   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
32693
32694   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
32695   {
32696     try {
32697       delete arg1;
32698     } CALL_CATCH_EXCEPTION();
32699   }
32700
32701 }
32702
32703
32704 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_0() {
32705   void * jresult ;
32706   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
32707
32708   {
32709     try {
32710       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >();
32711     } CALL_CATCH_EXCEPTION(0);
32712   }
32713
32714   jresult = (void *)result;
32715   return jresult;
32716 }
32717
32718
32719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) {
32720   void * jresult ;
32721   Dali::Radian arg1 ;
32722   Dali::Radian arg2 ;
32723   Dali::Radian *argp1 ;
32724   Dali::Radian *argp2 ;
32725   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
32726
32727   argp1 = (Dali::Radian *)jarg1;
32728   if (!argp1) {
32729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
32730     return 0;
32731   }
32732   arg1 = *argp1;
32733   argp2 = (Dali::Radian *)jarg2;
32734   if (!argp2) {
32735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
32736     return 0;
32737   }
32738   arg2 = *argp2;
32739   {
32740     try {
32741       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2);
32742     } CALL_CATCH_EXCEPTION(0);
32743   }
32744
32745   jresult = (void *)result;
32746   return jresult;
32747 }
32748
32749
32750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_2(void * jarg1) {
32751   void * jresult ;
32752   std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ;
32753   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
32754
32755   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
32756   if (!arg1) {
32757     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0);
32758     return 0;
32759   }
32760   {
32761     try {
32762       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > const &)*arg1);
32763     } CALL_CATCH_EXCEPTION(0);
32764   }
32765
32766   jresult = (void *)result;
32767   return jresult;
32768 }
32769
32770
32771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_set(void * jarg1, void * jarg2) {
32772   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
32773   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
32774
32775   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
32776   arg2 = (Dali::Radian *)jarg2;
32777   if (arg1) (arg1)->first = *arg2;
32778 }
32779
32780
32781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_get(void * jarg1) {
32782   void * jresult ;
32783   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
32784   Dali::Radian *result = 0 ;
32785
32786   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
32787   result = (Dali::Radian *)& ((arg1)->first);
32788   jresult = (void *)result;
32789   return jresult;
32790 }
32791
32792
32793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_set(void * jarg1, void * jarg2) {
32794   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
32795   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
32796
32797   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
32798   arg2 = (Dali::Radian *)jarg2;
32799   if (arg1) (arg1)->second = *arg2;
32800 }
32801
32802
32803 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_get(void * jarg1) {
32804   void * jresult ;
32805   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
32806   Dali::Radian *result = 0 ;
32807
32808   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
32809   result = (Dali::Radian *)& ((arg1)->second);
32810   jresult = (void *)result;
32811   return jresult;
32812 }
32813
32814
32815 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleThresholdPair(void * jarg1) {
32816   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
32817
32818   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
32819   {
32820     try {
32821       delete arg1;
32822     } CALL_CATCH_EXCEPTION();
32823   }
32824
32825 }
32826
32827
32828 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Empty(void * jarg1) {
32829   unsigned int jresult ;
32830   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
32831   bool result;
32832
32833   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
32834   {
32835     try {
32836       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);
32837     } CALL_CATCH_EXCEPTION(0);
32838   }
32839
32840   jresult = result;
32841   return jresult;
32842 }
32843
32844
32845 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) {
32846   unsigned long jresult ;
32847   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
32848   std::size_t result;
32849
32850   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
32851   {
32852     try {
32853       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);
32854     } CALL_CATCH_EXCEPTION(0);
32855   }
32856
32857   jresult = (unsigned long)result;
32858   return jresult;
32859 }
32860
32861
32862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
32863   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
32864   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
32865
32866   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
32867   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
32868   {
32869     try {
32870       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
32871     } CALL_CATCH_EXCEPTION();
32872   }
32873
32874 }
32875
32876
32877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
32878   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
32879   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
32880
32881   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
32882   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
32883   {
32884     try {
32885       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
32886     } CALL_CATCH_EXCEPTION();
32887   }
32888
32889 }
32890
32891
32892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
32893   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
32894   Dali::Actor arg2 ;
32895   Dali::PanGesture *arg3 = 0 ;
32896   Dali::Actor *argp2 ;
32897
32898   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
32899   argp2 = (Dali::Actor *)jarg2;
32900   if (!argp2) {
32901     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32902     return ;
32903   }
32904   arg2 = *argp2;
32905   arg3 = (Dali::PanGesture *)jarg3;
32906   if (!arg3) {
32907     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
32908     return ;
32909   }
32910   {
32911     try {
32912       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*arg3);
32913     } CALL_CATCH_EXCEPTION();
32914   }
32915
32916 }
32917
32918
32919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetectedSignal() {
32920   void * jresult ;
32921   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ;
32922
32923   {
32924     try {
32925       result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >();
32926     } CALL_CATCH_EXCEPTION(0);
32927   }
32928
32929   jresult = (void *)result;
32930   return jresult;
32931 }
32932
32933
32934 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetectedSignal(void * jarg1) {
32935   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
32936
32937   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
32938   {
32939     try {
32940       delete arg1;
32941     } CALL_CATCH_EXCEPTION();
32942   }
32943
32944 }
32945
32946
32947 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Empty(void * jarg1) {
32948   unsigned int jresult ;
32949   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
32950   bool result;
32951
32952   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
32953   {
32954     try {
32955       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);
32956     } CALL_CATCH_EXCEPTION(0);
32957   }
32958
32959   jresult = result;
32960   return jresult;
32961 }
32962
32963
32964 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) {
32965   unsigned long jresult ;
32966   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
32967   std::size_t result;
32968
32969   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
32970   {
32971     try {
32972       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);
32973     } CALL_CATCH_EXCEPTION(0);
32974   }
32975
32976   jresult = (unsigned long)result;
32977   return jresult;
32978 }
32979
32980
32981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
32982   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
32983   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
32984
32985   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
32986   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
32987   {
32988     try {
32989       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
32990     } CALL_CATCH_EXCEPTION();
32991   }
32992
32993 }
32994
32995
32996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
32997   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
32998   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
32999
33000   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
33001   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
33002   {
33003     try {
33004       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
33005     } CALL_CATCH_EXCEPTION();
33006   }
33007
33008 }
33009
33010
33011 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
33012   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
33013   Dali::Actor arg2 ;
33014   Dali::PinchGesture *arg3 = 0 ;
33015   Dali::Actor *argp2 ;
33016
33017   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
33018   argp2 = (Dali::Actor *)jarg2;
33019   if (!argp2) {
33020     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33021     return ;
33022   }
33023   arg2 = *argp2;
33024   arg3 = (Dali::PinchGesture *)jarg3;
33025   if (!arg3) {
33026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
33027     return ;
33028   }
33029   {
33030     try {
33031       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3);
33032     } CALL_CATCH_EXCEPTION();
33033   }
33034
33035 }
33036
33037
33038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetectedSignal() {
33039   void * jresult ;
33040   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ;
33041
33042   {
33043     try {
33044       result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >();
33045     } CALL_CATCH_EXCEPTION(0);
33046   }
33047
33048   jresult = (void *)result;
33049   return jresult;
33050 }
33051
33052
33053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetectedSignal(void * jarg1) {
33054   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
33055
33056   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
33057   {
33058     try {
33059       delete arg1;
33060     } CALL_CATCH_EXCEPTION();
33061   }
33062
33063 }
33064
33065
33066 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Empty(void * jarg1) {
33067   unsigned int jresult ;
33068   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
33069   bool result;
33070
33071   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
33072   {
33073     try {
33074       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);
33075     } CALL_CATCH_EXCEPTION(0);
33076   }
33077
33078   jresult = result;
33079   return jresult;
33080 }
33081
33082
33083 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) {
33084   unsigned long jresult ;
33085   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
33086   std::size_t result;
33087
33088   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
33089   {
33090     try {
33091       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);
33092     } CALL_CATCH_EXCEPTION(0);
33093   }
33094
33095   jresult = (unsigned long)result;
33096   return jresult;
33097 }
33098
33099
33100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
33101   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
33102   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
33103
33104   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
33105   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
33106   {
33107     try {
33108       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
33109     } CALL_CATCH_EXCEPTION();
33110   }
33111
33112 }
33113
33114
33115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
33116   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
33117   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
33118
33119   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
33120   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
33121   {
33122     try {
33123       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
33124     } CALL_CATCH_EXCEPTION();
33125   }
33126
33127 }
33128
33129
33130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
33131   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
33132   Dali::Actor arg2 ;
33133   Dali::TapGesture *arg3 = 0 ;
33134   Dali::Actor *argp2 ;
33135
33136   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
33137   argp2 = (Dali::Actor *)jarg2;
33138   if (!argp2) {
33139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33140     return ;
33141   }
33142   arg2 = *argp2;
33143   arg3 = (Dali::TapGesture *)jarg3;
33144   if (!arg3) {
33145     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
33146     return ;
33147   }
33148   {
33149     try {
33150       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3);
33151     } CALL_CATCH_EXCEPTION();
33152   }
33153
33154 }
33155
33156
33157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetectedSignal() {
33158   void * jresult ;
33159   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ;
33160
33161   {
33162     try {
33163       result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >();
33164     } CALL_CATCH_EXCEPTION(0);
33165   }
33166
33167   jresult = (void *)result;
33168   return jresult;
33169 }
33170
33171
33172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetectedSignal(void * jarg1) {
33173   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
33174
33175   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
33176   {
33177     try {
33178       delete arg1;
33179     } CALL_CATCH_EXCEPTION();
33180   }
33181
33182 }
33183
33184
33185 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionChangedSignal_Empty(void * jarg1) {
33186   unsigned int jresult ;
33187   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
33188   bool result = false;
33189
33190   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
33191   {
33192     try {
33193       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);
33194     } CALL_CATCH_EXCEPTION(0);
33195   }
33196   jresult = result;
33197   return jresult;
33198 }
33199
33200 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_GetConnectionCount(void * jarg1) {
33201   unsigned long jresult ;
33202   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
33203   std::size_t result = 0;
33204
33205   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
33206   {
33207     try {
33208       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);
33209     }CALL_CATCH_EXCEPTION(0);
33210   }
33211   jresult = (unsigned long)result;
33212   return jresult;
33213 }
33214
33215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Connect(void * jarg1, void * jarg2) {
33216   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
33217   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
33218
33219   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
33220   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
33221   {
33222     try {
33223       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Connect(arg1,arg2);
33224     } CALL_CATCH_EXCEPTION();
33225   }
33226 }
33227
33228 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Disconnect(void * jarg1, void * jarg2) {
33229   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
33230   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
33231
33232   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
33233   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
33234   {
33235     try {
33236       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Disconnect(arg1,arg2);
33237     } CALL_CATCH_EXCEPTION();
33238   }
33239 }
33240
33241 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Emit(void * jarg1, void * jarg2, int jarg4) {
33242   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
33243   Dali::Actor arg2 ;
33244   //bool arg3 ;
33245   Dali::LayoutDirection::Type arg4 ;
33246   Dali::Actor *argp2 ;
33247
33248   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
33249   argp2 = (Dali::Actor *)jarg2;
33250   if (!argp2) {
33251     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33252     return ;
33253   }
33254   arg2 = *argp2;
33255   //arg3 = jarg3 ? true : false;
33256   arg4 = (Dali::LayoutDirection::Type)jarg4;
33257   {
33258     try {
33259       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Emit(arg1,arg2,arg4);
33260     } CALL_CATCH_EXCEPTION();
33261   }
33262 }
33263
33264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewLayoutDirectionSignal() {
33265   void * jresult ;
33266   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *result = 0 ;
33267
33268   {
33269     try {
33270       result = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)new Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) >();
33271     } CALL_CATCH_EXCEPTION(0);
33272   }
33273   jresult = (void *)result;
33274   return jresult;
33275 }
33276
33277 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewLayoutDirectionSignal(void * jarg1) {
33278   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
33279
33280   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
33281   {
33282     try {
33283       delete arg1;
33284     } CALL_CATCH_EXCEPTION();
33285   }
33286 }
33287
33288
33289 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_iewVisibilityChangedSignal_Empty(void * jarg1) {
33290   unsigned int jresult ;
33291   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
33292   bool result = false;
33293
33294   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
33295   {
33296     try {
33297           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);
33298     } CALL_CATCH_EXCEPTION(0);
33299   }
33300   jresult = result;
33301   return jresult;
33302 }
33303
33304
33305 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_GetConnectionCount(void * jarg1) {
33306   unsigned long jresult ;
33307   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
33308   std::size_t result;
33309
33310   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
33311   {
33312     try {
33313       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);
33314     } CALL_CATCH_EXCEPTION(0);
33315   }
33316
33317   jresult = (unsigned long)result;
33318   return jresult;
33319 }
33320
33321
33322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Connect(void * jarg1, void * jarg2) {
33323   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
33324   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
33325
33326   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
33327   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
33328   {
33329     try {
33330       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(arg1,arg2);
33331     } CALL_CATCH_EXCEPTION();
33332   }
33333
33334 }
33335
33336
33337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Disconnect(void * jarg1, void * jarg2) {
33338   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
33339   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
33340
33341   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
33342   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
33343   {
33344     try {
33345       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(arg1,arg2);
33346     } CALL_CATCH_EXCEPTION();
33347   }
33348
33349 }
33350
33351
33352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, int jarg4) {
33353   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
33354   Dali::Actor arg2 ;
33355   bool arg3 ;
33356   Dali::DevelActor::VisibilityChange::Type arg4 ;
33357   Dali::Actor *argp2 ;
33358
33359   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
33360   argp2 = (Dali::Actor *)jarg2;
33361   if (!argp2) {
33362     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33363     return ;
33364   }
33365   arg2 = *argp2;
33366   arg3 = jarg3 ? true : false;
33367   arg4 = (Dali::DevelActor::VisibilityChange::Type)jarg4;
33368   {
33369     try {
33370       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(arg1,arg2,arg3,arg4);
33371     } CALL_CATCH_EXCEPTION();
33372   }
33373
33374 }
33375
33376
33377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewVisibilityChangedSignal() {
33378   void * jresult ;
33379   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *result = 0 ;
33380
33381   {
33382     try {
33383       result = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)new Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) >();
33384     } CALL_CATCH_EXCEPTION(0);
33385   }
33386
33387   jresult = (void *)result;
33388   return jresult;
33389 }
33390
33391
33392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewVisibilityChangedSignal(void * jarg1) {
33393   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
33394
33395   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
33396   {
33397     try {
33398       delete arg1;
33399     } CALL_CATCH_EXCEPTION();
33400   }
33401
33402 }
33403
33404
33405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_0() {
33406   void * jresult ;
33407   Dali::Timer *result = 0 ;
33408
33409   {
33410     try {
33411       result = (Dali::Timer *)new Dali::Timer();
33412     } CALL_CATCH_EXCEPTION(0);
33413   }
33414
33415   jresult = (void *)result;
33416   return jresult;
33417 }
33418
33419
33420 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_New(unsigned int jarg1) {
33421   void * jresult ;
33422   unsigned int arg1 ;
33423   Dali::Timer result;
33424
33425   arg1 = (unsigned int)jarg1;
33426   {
33427     try {
33428       result = Dali::Timer::New(arg1);
33429     } CALL_CATCH_EXCEPTION(0);
33430   }
33431
33432   jresult = new Dali::Timer((const Dali::Timer &)result);
33433   return jresult;
33434 }
33435
33436
33437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_1(void * jarg1) {
33438   void * jresult ;
33439   Dali::Timer *arg1 = 0 ;
33440   Dali::Timer *result = 0 ;
33441
33442   arg1 = (Dali::Timer *)jarg1;
33443   if (!arg1) {
33444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
33445     return 0;
33446   }
33447   {
33448     try {
33449       result = (Dali::Timer *)new Dali::Timer((Dali::Timer const &)*arg1);
33450     } CALL_CATCH_EXCEPTION(0);
33451   }
33452
33453   jresult = (void *)result;
33454   return jresult;
33455 }
33456
33457
33458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_Assign(void * jarg1, void * jarg2) {
33459   void * jresult ;
33460   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
33461   Dali::Timer *arg2 = 0 ;
33462   Dali::Timer *result = 0 ;
33463
33464   arg1 = (Dali::Timer *)jarg1;
33465   arg2 = (Dali::Timer *)jarg2;
33466   if (!arg2) {
33467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
33468     return 0;
33469   }
33470   {
33471     try {
33472       result = (Dali::Timer *) &(arg1)->operator =((Dali::Timer const &)*arg2);
33473     } CALL_CATCH_EXCEPTION(0);
33474   }
33475
33476   jresult = (void *)result;
33477   return jresult;
33478 }
33479
33480
33481 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Timer(void * jarg1) {
33482   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
33483
33484   arg1 = (Dali::Timer *)jarg1;
33485   {
33486     try {
33487       delete arg1;
33488     } CALL_CATCH_EXCEPTION();
33489   }
33490
33491 }
33492
33493
33494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_DownCast(void * jarg1) {
33495   void * jresult ;
33496   Dali::BaseHandle arg1 ;
33497   Dali::BaseHandle *argp1 ;
33498   Dali::Timer result;
33499
33500   argp1 = (Dali::BaseHandle *)jarg1;
33501   if (!argp1) {
33502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
33503     return 0;
33504   }
33505   arg1 = *argp1;
33506   {
33507     try {
33508       result = Dali::Timer::DownCast(arg1);
33509     } CALL_CATCH_EXCEPTION(0);
33510   }
33511
33512   jresult = new Dali::Timer((const Dali::Timer &)result);
33513   return jresult;
33514 }
33515
33516
33517 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Start(void * jarg1) {
33518   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
33519
33520   arg1 = (Dali::Timer *)jarg1;
33521   {
33522     try {
33523       (arg1)->Start();
33524     } CALL_CATCH_EXCEPTION();
33525   }
33526
33527 }
33528
33529
33530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Stop(void * jarg1) {
33531   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
33532
33533   arg1 = (Dali::Timer *)jarg1;
33534   {
33535     try {
33536       (arg1)->Stop();
33537     } CALL_CATCH_EXCEPTION();
33538   }
33539
33540 }
33541
33542
33543 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_SetInterval(void * jarg1, unsigned int jarg2) {
33544   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
33545   unsigned int arg2 ;
33546
33547   arg1 = (Dali::Timer *)jarg1;
33548   arg2 = (unsigned int)jarg2;
33549   {
33550     try {
33551       (arg1)->SetInterval(arg2);
33552     } CALL_CATCH_EXCEPTION();
33553   }
33554
33555 }
33556
33557
33558 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_GetInterval(void * jarg1) {
33559   unsigned int jresult ;
33560   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
33561   unsigned int result;
33562
33563   arg1 = (Dali::Timer *)jarg1;
33564   {
33565     try {
33566       result = (unsigned int)((Dali::Timer const *)arg1)->GetInterval();
33567     } CALL_CATCH_EXCEPTION(0);
33568   }
33569
33570   jresult = result;
33571   return jresult;
33572 }
33573
33574
33575 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_IsRunning(void * jarg1) {
33576   unsigned int jresult ;
33577   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
33578   bool result;
33579
33580   arg1 = (Dali::Timer *)jarg1;
33581   {
33582     try {
33583       result = (bool)((Dali::Timer const *)arg1)->IsRunning();
33584     } CALL_CATCH_EXCEPTION(0);
33585   }
33586
33587   jresult = result;
33588   return jresult;
33589 }
33590
33591
33592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_TickSignal(void * jarg1) {
33593   void * jresult ;
33594   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
33595   Dali::Timer::TimerSignalType *result = 0 ;
33596
33597   arg1 = (Dali::Timer *)jarg1;
33598   {
33599     try {
33600       result = (Dali::Timer::TimerSignalType *) &(arg1)->TickSignal();
33601     } CALL_CATCH_EXCEPTION(0);
33602   }
33603
33604   jresult = (void *)result;
33605   return jresult;
33606 }
33607
33608
33609 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Empty(void * jarg1) {
33610   unsigned int jresult ;
33611   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
33612   bool result;
33613
33614   arg1 = (Dali::Signal< bool () > *)jarg1;
33615   {
33616     try {
33617       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Empty((Dali::Signal< bool () > const *)arg1);
33618     } CALL_CATCH_EXCEPTION(0);
33619   }
33620
33621   jresult = result;
33622   return jresult;
33623 }
33624
33625
33626 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TimerSignalType_GetConnectionCount(void * jarg1) {
33627   unsigned long jresult ;
33628   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
33629   std::size_t result;
33630
33631   arg1 = (Dali::Signal< bool () > *)jarg1;
33632   {
33633     try {
33634       result = Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount((Dali::Signal< bool () > const *)arg1);
33635     } CALL_CATCH_EXCEPTION(0);
33636   }
33637
33638   jresult = (unsigned long)result;
33639   return jresult;
33640 }
33641
33642
33643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect(void * jarg1, void * jarg2) {
33644   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
33645   bool (*arg2)() = (bool (*)()) 0 ;
33646
33647   arg1 = (Dali::Signal< bool () > *)jarg1;
33648   arg2 = (bool (*)())jarg2;
33649   {
33650     try {
33651       Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(arg1,arg2);
33652     } CALL_CATCH_EXCEPTION();
33653   }
33654
33655 }
33656
33657
33658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Disconnect(void * jarg1, void * jarg2) {
33659   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
33660   bool (*arg2)() = (bool (*)()) 0 ;
33661
33662   arg1 = (Dali::Signal< bool () > *)jarg1;
33663   arg2 = (bool (*)())jarg2;
33664   {
33665     try {
33666       Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(arg1,arg2);
33667     } CALL_CATCH_EXCEPTION();
33668   }
33669
33670 }
33671
33672
33673 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Emit(void * jarg1) {
33674   unsigned int jresult ;
33675   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
33676   bool result;
33677
33678   arg1 = (Dali::Signal< bool () > *)jarg1;
33679   {
33680     try {
33681       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(arg1);
33682     } CALL_CATCH_EXCEPTION(0);
33683   }
33684
33685   jresult = result;
33686   return jresult;
33687 }
33688
33689
33690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimerSignalType() {
33691   void * jresult ;
33692   Dali::Signal< bool () > *result = 0 ;
33693
33694   {
33695     try {
33696       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
33697     } CALL_CATCH_EXCEPTION(0);
33698   }
33699
33700   jresult = (void *)result;
33701   return jresult;
33702 }
33703
33704
33705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimerSignalType(void * jarg1) {
33706   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
33707
33708   arg1 = (Dali::Signal< bool () > *)jarg1;
33709   {
33710     try {
33711       delete arg1;
33712     } CALL_CATCH_EXCEPTION();
33713   }
33714
33715 }
33716
33717
33718 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() {
33719   int jresult ;
33720   int result;
33721
33722   {
33723     try {
33724       result = (int)Dali::Toolkit::Visual::Property::TYPE;
33725     } CALL_CATCH_EXCEPTION(0);
33726   }
33727
33728   jresult = (int)result;
33729   return jresult;
33730 }
33731
33732
33733 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_SHADER_get() {
33734   int jresult ;
33735   int result;
33736
33737   {
33738     try {
33739       result = (int)Dali::Toolkit::Visual::Property::SHADER;
33740     } CALL_CATCH_EXCEPTION(0);
33741   }
33742
33743   jresult = (int)result;
33744   return jresult;
33745 }
33746
33747
33748 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_VERTEX_get() {
33749   int jresult ;
33750   int result;
33751
33752   {
33753     try {
33754       result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
33755     } CALL_CATCH_EXCEPTION(0);
33756   }
33757
33758   jresult = (int)result;
33759   return jresult;
33760 }
33761
33762
33763 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_FRAGMENT_get() {
33764   int jresult ;
33765   int result;
33766
33767   {
33768     try {
33769       result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER;
33770     } CALL_CATCH_EXCEPTION(0);
33771   }
33772
33773   jresult = (int)result;
33774   return jresult;
33775 }
33776
33777
33778 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_X_get() {
33779   int jresult ;
33780   int result;
33781
33782   {
33783     try {
33784       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X;
33785     } CALL_CATCH_EXCEPTION(0);
33786   }
33787
33788   jresult = (int)result;
33789   return jresult;
33790 }
33791
33792
33793 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_Y_get() {
33794   int jresult ;
33795   int result;
33796
33797   {
33798     try {
33799       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y;
33800     } CALL_CATCH_EXCEPTION(0);
33801   }
33802
33803   jresult = (int)result;
33804   return jresult;
33805 }
33806
33807
33808 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_HINTS_get() {
33809   int jresult ;
33810   int result;
33811
33812   {
33813     try {
33814       result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS;
33815     } CALL_CATCH_EXCEPTION(0);
33816   }
33817
33818   jresult = (int)result;
33819   return jresult;
33820 }
33821
33822
33823 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_COLOR_get() {
33824   int jresult ;
33825   int result;
33826
33827   {
33828     try {
33829       result = (int)Dali::Toolkit::BorderVisual::Property::COLOR;
33830     } CALL_CATCH_EXCEPTION(0);
33831   }
33832
33833   jresult = (int)result;
33834   return jresult;
33835 }
33836
33837
33838 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_SIZE_get() {
33839   int jresult ;
33840   int result;
33841
33842   {
33843     try {
33844       result = (int)Dali::Toolkit::BorderVisual::Property::SIZE;
33845     } CALL_CATCH_EXCEPTION(0);
33846   }
33847
33848   jresult = (int)result;
33849   return jresult;
33850 }
33851
33852
33853 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_ANTI_ALIASING_get() {
33854   int jresult ;
33855   int result;
33856
33857   {
33858     try {
33859       result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING;
33860     } CALL_CATCH_EXCEPTION(0);
33861   }
33862
33863   jresult = (int)result;
33864   return jresult;
33865 }
33866
33867
33868 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_COLOR_VISUAL_MIX_COLOR_get() {
33869   int jresult ;
33870   int result;
33871
33872   {
33873     try {
33874       result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR;
33875     } CALL_CATCH_EXCEPTION(0);
33876   }
33877
33878   jresult = (int)result;
33879   return jresult;
33880 }
33881
33882
33883 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_START_POSITION_get() {
33884   int jresult ;
33885   int result;
33886
33887   {
33888     try {
33889       result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION;
33890     } CALL_CATCH_EXCEPTION(0);
33891   }
33892
33893   jresult = (int)result;
33894   return jresult;
33895 }
33896
33897
33898 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_END_POSITION_get() {
33899   int jresult ;
33900   int result;
33901
33902   {
33903     try {
33904       result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION;
33905     } CALL_CATCH_EXCEPTION(0);
33906   }
33907
33908   jresult = (int)result;
33909   return jresult;
33910 }
33911
33912
33913 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_CENTER_get() {
33914   int jresult ;
33915   int result;
33916
33917   {
33918     try {
33919       result = (int)Dali::Toolkit::GradientVisual::Property::CENTER;
33920     } CALL_CATCH_EXCEPTION(0);
33921   }
33922
33923   jresult = (int)result;
33924   return jresult;
33925 }
33926
33927
33928 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_RADIUS_get() {
33929   int jresult ;
33930   int result;
33931
33932   {
33933     try {
33934       result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS;
33935     } CALL_CATCH_EXCEPTION(0);
33936   }
33937
33938   jresult = (int)result;
33939   return jresult;
33940 }
33941
33942
33943 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_OFFSET_get() {
33944   int jresult ;
33945   int result;
33946
33947   {
33948     try {
33949       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET;
33950     } CALL_CATCH_EXCEPTION(0);
33951   }
33952
33953   jresult = (int)result;
33954   return jresult;
33955 }
33956
33957
33958 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_COLOR_get() {
33959   int jresult ;
33960   int result;
33961
33962   {
33963     try {
33964       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR;
33965     } CALL_CATCH_EXCEPTION(0);
33966   }
33967
33968   jresult = (int)result;
33969   return jresult;
33970 }
33971
33972
33973 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_UNITS_get() {
33974   int jresult ;
33975   int result;
33976
33977   {
33978     try {
33979       result = (int)Dali::Toolkit::GradientVisual::Property::UNITS;
33980     } CALL_CATCH_EXCEPTION(0);
33981   }
33982
33983   jresult = (int)result;
33984   return jresult;
33985 }
33986
33987
33988 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_SPREAD_METHOD_get() {
33989   int jresult ;
33990   int result;
33991
33992   {
33993     try {
33994       result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD;
33995     } CALL_CATCH_EXCEPTION(0);
33996   }
33997
33998   jresult = (int)result;
33999   return jresult;
34000 }
34001
34002
34003 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_URL_get() {
34004   int jresult ;
34005   int result;
34006
34007   {
34008     try {
34009       result = (int)Dali::Toolkit::ImageVisual::Property::URL;
34010     } CALL_CATCH_EXCEPTION(0);
34011   }
34012
34013   jresult = (int)result;
34014   return jresult;
34015 }
34016
34017 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ALPHA_MASK_URL_get() {
34018   int jresult ;
34019   int result;
34020
34021   {
34022     try {
34023       result = (int)Dali::Toolkit::ImageVisual::Property::ALPHA_MASK_URL;
34024     } CALL_CATCH_EXCEPTION(0);
34025   }
34026
34027   jresult = (int)result;
34028   return jresult;
34029 }
34030
34031
34032 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BATCH_SIZE_get() {
34033   int jresult ;
34034   int result;
34035   {
34036     try
34037     {
34038       result = (int)Dali::Toolkit::ImageVisual::Property::BATCH_SIZE;
34039     } CALL_CATCH_EXCEPTION(0);
34040   }
34041
34042   jresult = (int)result;
34043   return jresult;
34044 }
34045
34046 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CACHE_SIZE_get() {
34047   int jresult ;
34048   int result;
34049   {
34050     try
34051     {
34052       result = (int)Dali::Toolkit::ImageVisual::Property::CACHE_SIZE;
34053     } CALL_CATCH_EXCEPTION(0);
34054   }
34055
34056   jresult = (int)result;
34057   return jresult;
34058 }
34059
34060 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FRAME_DELAY_get() {
34061   int jresult ;
34062   int result;
34063   {
34064     try
34065     {
34066       result = (int)Dali::Toolkit::ImageVisual::Property::FRAME_DELAY;
34067     } CALL_CATCH_EXCEPTION(0);
34068   }
34069
34070   jresult = (int)result;
34071   return jresult;
34072 }
34073
34074 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOOP_COUNT_get() {
34075   return (int)Dali::Toolkit::DevelImageVisual::Property::LOOP_COUNT;
34076 }
34077
34078 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_MASK_CONTENT_SCALE_get() {
34079   int jresult ;
34080   int result;
34081   {
34082     try
34083     {
34084       result = (int)Dali::Toolkit::ImageVisual::Property::MASK_CONTENT_SCALE;
34085     } CALL_CATCH_EXCEPTION(0);
34086   }
34087
34088   jresult = (int)result;
34089   return jresult;
34090 }
34091
34092 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CROP_TO_MASK_get() {
34093   int jresult ;
34094   int result;
34095   {
34096     try
34097     {
34098       result = (int)Dali::Toolkit::ImageVisual::Property::CROP_TO_MASK;
34099     } CALL_CATCH_EXCEPTION(0);
34100   }
34101
34102   jresult = (int)result;
34103   return jresult;
34104 }
34105
34106 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() {
34107   int jresult ;
34108   int result;
34109
34110   {
34111     try {
34112       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE;
34113     } CALL_CATCH_EXCEPTION(0);
34114   }
34115
34116   jresult = (int)result;
34117   return jresult;
34118 }
34119
34120
34121 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SAMPLING_MODE_get() {
34122   int jresult ;
34123   int result;
34124
34125   {
34126     try {
34127       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
34128     } CALL_CATCH_EXCEPTION(0);
34129   }
34130
34131   jresult = (int)result;
34132   return jresult;
34133 }
34134
34135 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_RELEASE_POLICY_get() {
34136   int jresult ;
34137   int result;
34138   {
34139     try
34140     {
34141       result = (int)Dali::Toolkit::ImageVisual::Property::RELEASE_POLICY;
34142     } CALL_CATCH_EXCEPTION(0);
34143   }
34144
34145   jresult = (int)result;
34146   return jresult;
34147 }
34148
34149 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOAD_POLICY_get() {
34150   int jresult ;
34151   int result;
34152   {
34153     try
34154     {
34155       result = (int)Dali::Toolkit::ImageVisual::Property::LOAD_POLICY;
34156     } CALL_CATCH_EXCEPTION(0);
34157   }
34158
34159   jresult = (int)result;
34160   return jresult;
34161 }
34162
34163 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ORIENTATION_CORRECTION_get() {
34164   int jresult ;
34165   int result;
34166   {
34167     try
34168     {
34169       result = (int)Dali::Toolkit::ImageVisual::Property::ORIENTATION_CORRECTION;
34170     } CALL_CATCH_EXCEPTION(0);
34171   }
34172
34173   jresult = (int)result;
34174   return jresult;
34175 }
34176
34177
34178 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_URL_get() {
34179   int jresult ;
34180   int result;
34181   {
34182     try
34183     {
34184       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE;
34185     } CALL_CATCH_EXCEPTION(0);
34186   }
34187
34188   jresult = (int)result;
34189   return jresult;
34190 }
34191
34192 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_ALPHA_get() {
34193   int jresult ;
34194   int result;
34195   {
34196     try
34197     {
34198       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA;
34199     } CALL_CATCH_EXCEPTION(0);
34200   }
34201
34202   jresult = (int)result;
34203   return jresult;
34204 }
34205
34206
34207
34208 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() {
34209   int jresult ;
34210   int result;
34211
34212   {
34213     try {
34214       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
34215     } CALL_CATCH_EXCEPTION(0);
34216   }
34217
34218   jresult = (int)result;
34219   return jresult;
34220 }
34221
34222
34223 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
34224   int jresult ;
34225   int result;
34226
34227   {
34228     try {
34229       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
34230     } CALL_CATCH_EXCEPTION(0);
34231   }
34232
34233   jresult = (int)result;
34234   return jresult;
34235 }
34236
34237
34238 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
34239   int jresult ;
34240   int result;
34241
34242   {
34243     try {
34244       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
34245     } CALL_CATCH_EXCEPTION(0);
34246   }
34247
34248   jresult = (int)result;
34249   return jresult;
34250 }
34251
34252
34253 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() {
34254   int jresult ;
34255   int result;
34256
34257   {
34258     try {
34259       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
34260     } CALL_CATCH_EXCEPTION(0);
34261   }
34262
34263   jresult = (int)result;
34264   return jresult;
34265 }
34266
34267
34268 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() {
34269   int jresult ;
34270   int result;
34271
34272   {
34273     try {
34274       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
34275     } CALL_CATCH_EXCEPTION(0);
34276   }
34277
34278   jresult = (int)result;
34279   return jresult;
34280 }
34281
34282
34283 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() {
34284   int jresult ;
34285   int result;
34286
34287   {
34288     try {
34289       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
34290     } CALL_CATCH_EXCEPTION(0);
34291   }
34292
34293   jresult = (int)result;
34294   return jresult;
34295 }
34296
34297
34298 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get() {
34299   int jresult ;
34300   int result;
34301
34302   {
34303     try {
34304       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
34305     } CALL_CATCH_EXCEPTION(0);
34306   }
34307
34308   jresult = (int)result;
34309   return jresult;
34310 }
34311
34312 SWIGEXPORT int SWIGSTDCALL CSharp_Image_Visual_BORDER_get() {
34313   int jresult ;
34314   int result;
34315
34316   {
34317     try {
34318       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER;
34319     } CALL_CATCH_EXCEPTION(0);
34320   }
34321
34322   jresult = (int)result;
34323   return jresult;
34324 }
34325
34326 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() {
34327   int jresult ;
34328   int result;
34329
34330   {
34331     try {
34332       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
34333     } CALL_CATCH_EXCEPTION(0);
34334   }
34335
34336   jresult = (int)result;
34337   return jresult;
34338 }
34339
34340
34341 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() {
34342   int jresult ;
34343   int result;
34344
34345   {
34346     try {
34347       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
34348     } CALL_CATCH_EXCEPTION(0);
34349   }
34350
34351   jresult = (int)result;
34352   return jresult;
34353 }
34354
34355
34356 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() {
34357   int jresult ;
34358   int result;
34359
34360   {
34361     try {
34362       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
34363     } CALL_CATCH_EXCEPTION(0);
34364   }
34365
34366   jresult = (int)result;
34367   return jresult;
34368 }
34369
34370
34371 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() {
34372   int jresult ;
34373   int result;
34374
34375   {
34376     try {
34377       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
34378     } CALL_CATCH_EXCEPTION(0);
34379   }
34380
34381   jresult = (int)result;
34382   return jresult;
34383 }
34384
34385
34386 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() {
34387   int jresult ;
34388   int result;
34389
34390   {
34391     try {
34392       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
34393     } CALL_CATCH_EXCEPTION(0);
34394   }
34395
34396   jresult = (int)result;
34397   return jresult;
34398 }
34399
34400
34401 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() {
34402   int jresult ;
34403   int result;
34404
34405   {
34406     try {
34407       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
34408     } CALL_CATCH_EXCEPTION(0);
34409   }
34410
34411   jresult = (int)result;
34412   return jresult;
34413 }
34414
34415
34416 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() {
34417   int jresult ;
34418   int result;
34419
34420   {
34421     try {
34422       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
34423     } CALL_CATCH_EXCEPTION(0);
34424   }
34425
34426   jresult = (int)result;
34427   return jresult;
34428 }
34429
34430
34431 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() {
34432   int jresult ;
34433   int result;
34434
34435   {
34436     try {
34437       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
34438     } CALL_CATCH_EXCEPTION(0);
34439   }
34440
34441   jresult = (int)result;
34442   return jresult;
34443 }
34444
34445
34446 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
34447   int jresult ;
34448   int result;
34449
34450   {
34451     try {
34452       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
34453     } CALL_CATCH_EXCEPTION(0);
34454   }
34455
34456   jresult = (int)result;
34457   return jresult;
34458 }
34459
34460
34461 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() {
34462   int jresult ;
34463   int result;
34464
34465   {
34466     try {
34467       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
34468     } CALL_CATCH_EXCEPTION(0);
34469   }
34470
34471   jresult = (int)result;
34472   return jresult;
34473 }
34474
34475
34476 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() {
34477   int jresult ;
34478   int result;
34479
34480   {
34481     try {
34482       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
34483     } CALL_CATCH_EXCEPTION(0);
34484   }
34485
34486   jresult = (int)result;
34487   return jresult;
34488 }
34489
34490
34491 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() {
34492   int jresult ;
34493   int result;
34494
34495   {
34496     try {
34497       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
34498     } CALL_CATCH_EXCEPTION(0);
34499   }
34500
34501   jresult = (int)result;
34502   return jresult;
34503 }
34504
34505
34506 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() {
34507   int jresult ;
34508   int result;
34509
34510   {
34511     try {
34512       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
34513     } CALL_CATCH_EXCEPTION(0);
34514   }
34515
34516   jresult = (int)result;
34517   return jresult;
34518 }
34519
34520
34521 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() {
34522   int jresult ;
34523   int result;
34524
34525   {
34526     try {
34527       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
34528     } CALL_CATCH_EXCEPTION(0);
34529   }
34530
34531   jresult = (int)result;
34532   return jresult;
34533 }
34534
34535
34536 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() {
34537   int jresult ;
34538   int result;
34539
34540   {
34541     try {
34542       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
34543     } CALL_CATCH_EXCEPTION(0);
34544   }
34545
34546   jresult = (int)result;
34547   return jresult;
34548 }
34549
34550
34551 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() {
34552   int jresult ;
34553   int result;
34554
34555   {
34556     try {
34557       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
34558     } CALL_CATCH_EXCEPTION(0);
34559   }
34560
34561   jresult = (int)result;
34562   return jresult;
34563 }
34564
34565
34566 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() {
34567   int jresult ;
34568   int result;
34569
34570   {
34571     try {
34572       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
34573     } CALL_CATCH_EXCEPTION(0);
34574   }
34575
34576   jresult = (int)result;
34577   return jresult;
34578 }
34579
34580
34581 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() {
34582   int jresult ;
34583   int result;
34584
34585   {
34586     try {
34587       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
34588     } CALL_CATCH_EXCEPTION(0);
34589   }
34590
34591   jresult = (int)result;
34592   return jresult;
34593 }
34594
34595
34596 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
34597   int jresult ;
34598   int result;
34599
34600   {
34601     try {
34602       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
34603     } CALL_CATCH_EXCEPTION(0);
34604   }
34605
34606   jresult = (int)result;
34607   return jresult;
34608 }
34609
34610
34611 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_get() {
34612   int jresult ;
34613   int result;
34614
34615   {
34616     try {
34617       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
34618     } CALL_CATCH_EXCEPTION(0);
34619   }
34620
34621   jresult = (int)result;
34622   return jresult;
34623 }
34624
34625
34626 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() {
34627   int jresult ;
34628   int result;
34629
34630   {
34631     try {
34632       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
34633     } CALL_CATCH_EXCEPTION(0);
34634   }
34635
34636   jresult = (int)result;
34637   return jresult;
34638 }
34639
34640
34641 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() {
34642   int jresult ;
34643   int result;
34644
34645   {
34646     try {
34647       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
34648     } CALL_CATCH_EXCEPTION(0);
34649   }
34650
34651   jresult = (int)result;
34652   return jresult;
34653 }
34654
34655
34656 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() {
34657   int jresult ;
34658   int result;
34659
34660   {
34661     try {
34662       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
34663     } CALL_CATCH_EXCEPTION(0);
34664   }
34665
34666   jresult = (int)result;
34667   return jresult;
34668 }
34669
34670
34671 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() {
34672   int jresult ;
34673   int result;
34674
34675   {
34676     try {
34677       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
34678     } CALL_CATCH_EXCEPTION(0);
34679   }
34680
34681   jresult = (int)result;
34682   return jresult;
34683 }
34684
34685
34686 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() {
34687   int jresult ;
34688   int result;
34689
34690   {
34691     try {
34692       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
34693     } CALL_CATCH_EXCEPTION(0);
34694   }
34695
34696   jresult = (int)result;
34697   return jresult;
34698 }
34699
34700
34701 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() {
34702   int jresult ;
34703   int result;
34704
34705   {
34706     try {
34707       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
34708     } CALL_CATCH_EXCEPTION(0);
34709   }
34710
34711   jresult = (int)result;
34712   return jresult;
34713 }
34714
34715
34716 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() {
34717   int jresult ;
34718   int result;
34719
34720   {
34721     try {
34722       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
34723     } CALL_CATCH_EXCEPTION(0);
34724   }
34725
34726   jresult = (int)result;
34727   return jresult;
34728 }
34729
34730
34731 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() {
34732   int jresult ;
34733   int result;
34734
34735   {
34736     try {
34737       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
34738     } CALL_CATCH_EXCEPTION(0);
34739   }
34740
34741   jresult = (int)result;
34742   return jresult;
34743 }
34744
34745
34746 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() {
34747   void * jresult ;
34748   Dali::Toolkit::Builder *result = 0 ;
34749
34750   {
34751     try {
34752       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
34753     } CALL_CATCH_EXCEPTION(0);
34754   }
34755
34756   jresult = (void *)result;
34757   return jresult;
34758 }
34759
34760
34761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() {
34762   void * jresult ;
34763   Dali::Toolkit::Builder result;
34764
34765   {
34766     try {
34767       result = Dali::Toolkit::Builder::New();
34768     } CALL_CATCH_EXCEPTION(0);
34769   }
34770
34771   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
34772   return jresult;
34773 }
34774
34775
34776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
34777   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
34778
34779   arg1 = (Dali::Toolkit::Builder *)jarg1;
34780   {
34781     try {
34782       delete arg1;
34783     } CALL_CATCH_EXCEPTION();
34784   }
34785
34786 }
34787
34788
34789 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
34790   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
34791   std::string *arg2 = 0 ;
34792   Dali::Toolkit::Builder::UIFormat arg3 ;
34793
34794   arg1 = (Dali::Toolkit::Builder *)jarg1;
34795   if (!jarg2) {
34796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
34797     return ;
34798   }
34799   std::string arg2_str(jarg2);
34800   arg2 = &arg2_str;
34801   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
34802   {
34803     try {
34804       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
34805     } CALL_CATCH_EXCEPTION();
34806   }
34807
34808
34809   //argout typemap for const std::string&
34810
34811 }
34812
34813
34814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
34815   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
34816   std::string *arg2 = 0 ;
34817
34818   arg1 = (Dali::Toolkit::Builder *)jarg1;
34819   if (!jarg2) {
34820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
34821     return ;
34822   }
34823   std::string arg2_str(jarg2);
34824   arg2 = &arg2_str;
34825   {
34826     try {
34827       (arg1)->LoadFromString((std::string const &)*arg2);
34828     } CALL_CATCH_EXCEPTION();
34829   }
34830
34831
34832   //argout typemap for const std::string&
34833
34834 }
34835
34836
34837 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) {
34838   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
34839   Dali::Property::Map *arg2 = 0 ;
34840
34841   arg1 = (Dali::Toolkit::Builder *)jarg1;
34842   arg2 = (Dali::Property::Map *)jarg2;
34843   if (!arg2) {
34844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
34845     return ;
34846   }
34847   {
34848     try {
34849       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
34850     } CALL_CATCH_EXCEPTION();
34851   }
34852
34853 }
34854
34855
34856 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
34857   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
34858   std::string *arg2 = 0 ;
34859   Dali::Property::Value *arg3 = 0 ;
34860
34861   arg1 = (Dali::Toolkit::Builder *)jarg1;
34862   if (!jarg2) {
34863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
34864     return ;
34865   }
34866   std::string arg2_str(jarg2);
34867   arg2 = &arg2_str;
34868   arg3 = (Dali::Property::Value *)jarg3;
34869   if (!arg3) {
34870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
34871     return ;
34872   }
34873   {
34874     try {
34875       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
34876     } CALL_CATCH_EXCEPTION();
34877   }
34878
34879
34880   //argout typemap for const std::string&
34881
34882 }
34883
34884
34885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
34886   void * jresult ;
34887   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
34888   Dali::Property::Map *result = 0 ;
34889
34890   arg1 = (Dali::Toolkit::Builder *)jarg1;
34891   {
34892     try {
34893       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
34894     } CALL_CATCH_EXCEPTION(0);
34895   }
34896
34897   jresult = (void *)result;
34898   return jresult;
34899 }
34900
34901
34902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) {
34903   void * jresult ;
34904   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
34905   std::string *arg2 = 0 ;
34906   Dali::Property::Value *result = 0 ;
34907
34908   arg1 = (Dali::Toolkit::Builder *)jarg1;
34909   if (!jarg2) {
34910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
34911     return 0;
34912   }
34913   std::string arg2_str(jarg2);
34914   arg2 = &arg2_str;
34915   {
34916     try {
34917       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
34918     } CALL_CATCH_EXCEPTION(0);
34919   }
34920
34921   jresult = (void *)result;
34922
34923   //argout typemap for const std::string&
34924
34925   return jresult;
34926 }
34927
34928
34929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
34930   void * jresult ;
34931   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
34932   std::string *arg2 = 0 ;
34933   Dali::Animation result;
34934
34935   arg1 = (Dali::Toolkit::Builder *)jarg1;
34936   if (!jarg2) {
34937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
34938     return 0;
34939   }
34940   std::string arg2_str(jarg2);
34941   arg2 = &arg2_str;
34942   {
34943     try {
34944       result = (arg1)->CreateAnimation((std::string const &)*arg2);
34945     } CALL_CATCH_EXCEPTION(0);
34946   }
34947
34948   jresult = new Dali::Animation((const Dali::Animation &)result);
34949
34950   //argout typemap for const std::string&
34951
34952   return jresult;
34953 }
34954
34955
34956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
34957   void * jresult ;
34958   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
34959   std::string *arg2 = 0 ;
34960   Dali::Property::Map *arg3 = 0 ;
34961   Dali::Animation result;
34962
34963   arg1 = (Dali::Toolkit::Builder *)jarg1;
34964   if (!jarg2) {
34965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
34966     return 0;
34967   }
34968   std::string arg2_str(jarg2);
34969   arg2 = &arg2_str;
34970   arg3 = (Dali::Property::Map *)jarg3;
34971   if (!arg3) {
34972     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
34973     return 0;
34974   }
34975   {
34976     try {
34977       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
34978     } CALL_CATCH_EXCEPTION(0);
34979   }
34980
34981   jresult = new Dali::Animation((const Dali::Animation &)result);
34982
34983   //argout typemap for const std::string&
34984
34985   return jresult;
34986 }
34987
34988
34989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
34990   void * jresult ;
34991   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
34992   std::string *arg2 = 0 ;
34993   Dali::Actor arg3 ;
34994   Dali::Actor *argp3 ;
34995   Dali::Animation result;
34996
34997   arg1 = (Dali::Toolkit::Builder *)jarg1;
34998   if (!jarg2) {
34999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
35000     return 0;
35001   }
35002   std::string arg2_str(jarg2);
35003   arg2 = &arg2_str;
35004   argp3 = (Dali::Actor *)jarg3;
35005   if (!argp3) {
35006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
35007     return 0;
35008   }
35009   arg3 = *argp3;
35010   {
35011     try {
35012       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
35013     } CALL_CATCH_EXCEPTION(0);
35014   }
35015
35016   jresult = new Dali::Animation((const Dali::Animation &)result);
35017
35018   //argout typemap for const std::string&
35019
35020   return jresult;
35021 }
35022
35023
35024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
35025   void * jresult ;
35026   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
35027   std::string *arg2 = 0 ;
35028   Dali::Property::Map *arg3 = 0 ;
35029   Dali::Actor arg4 ;
35030   Dali::Actor *argp4 ;
35031   Dali::Animation result;
35032
35033   arg1 = (Dali::Toolkit::Builder *)jarg1;
35034   if (!jarg2) {
35035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
35036     return 0;
35037   }
35038   std::string arg2_str(jarg2);
35039   arg2 = &arg2_str;
35040   arg3 = (Dali::Property::Map *)jarg3;
35041   if (!arg3) {
35042     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
35043     return 0;
35044   }
35045   argp4 = (Dali::Actor *)jarg4;
35046   if (!argp4) {
35047     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
35048     return 0;
35049   }
35050   arg4 = *argp4;
35051   {
35052     try {
35053       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
35054     } CALL_CATCH_EXCEPTION(0);
35055   }
35056
35057   jresult = new Dali::Animation((const Dali::Animation &)result);
35058
35059   //argout typemap for const std::string&
35060
35061   return jresult;
35062 }
35063
35064
35065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
35066   void * jresult ;
35067   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
35068   std::string *arg2 = 0 ;
35069   Dali::BaseHandle result;
35070
35071   arg1 = (Dali::Toolkit::Builder *)jarg1;
35072   if (!jarg2) {
35073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
35074     return 0;
35075   }
35076   std::string arg2_str(jarg2);
35077   arg2 = &arg2_str;
35078   {
35079     try {
35080       result = (arg1)->Create((std::string const &)*arg2);
35081     } CALL_CATCH_EXCEPTION(0);
35082   }
35083
35084   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
35085
35086   //argout typemap for const std::string&
35087
35088   return jresult;
35089 }
35090
35091
35092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
35093   void * jresult ;
35094   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
35095   std::string *arg2 = 0 ;
35096   Dali::Property::Map *arg3 = 0 ;
35097   Dali::BaseHandle result;
35098
35099   arg1 = (Dali::Toolkit::Builder *)jarg1;
35100   if (!jarg2) {
35101     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
35102     return 0;
35103   }
35104   std::string arg2_str(jarg2);
35105   arg2 = &arg2_str;
35106   arg3 = (Dali::Property::Map *)jarg3;
35107   if (!arg3) {
35108     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
35109     return 0;
35110   }
35111   {
35112     try {
35113       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
35114     } CALL_CATCH_EXCEPTION(0);
35115   }
35116
35117   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
35118
35119   //argout typemap for const std::string&
35120
35121   return jresult;
35122 }
35123
35124
35125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
35126   void * jresult ;
35127   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
35128   std::string *arg2 = 0 ;
35129   Dali::BaseHandle result;
35130
35131   arg1 = (Dali::Toolkit::Builder *)jarg1;
35132   if (!jarg2) {
35133     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
35134     return 0;
35135   }
35136   std::string arg2_str(jarg2);
35137   arg2 = &arg2_str;
35138   {
35139     try {
35140       result = (arg1)->CreateFromJson((std::string const &)*arg2);
35141     } CALL_CATCH_EXCEPTION(0);
35142   }
35143
35144   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
35145
35146   //argout typemap for const std::string&
35147
35148   return jresult;
35149 }
35150
35151
35152 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
35153   unsigned int jresult ;
35154   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
35155   std::string *arg2 = 0 ;
35156   Dali::Handle *arg3 = 0 ;
35157   bool result;
35158
35159   arg1 = (Dali::Toolkit::Builder *)jarg1;
35160   if (!jarg2) {
35161     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
35162     return 0;
35163   }
35164   std::string arg2_str(jarg2);
35165   arg2 = &arg2_str;
35166   arg3 = (Dali::Handle *)jarg3;
35167   if (!arg3) {
35168     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
35169     return 0;
35170   }
35171   {
35172     try {
35173       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
35174     } CALL_CATCH_EXCEPTION(0);
35175   }
35176
35177   jresult = result;
35178
35179   //argout typemap for const std::string&
35180
35181   return jresult;
35182 }
35183
35184
35185 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
35186   unsigned int jresult ;
35187   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
35188   Dali::Handle *arg2 = 0 ;
35189   std::string *arg3 = 0 ;
35190   bool result;
35191
35192   arg1 = (Dali::Toolkit::Builder *)jarg1;
35193   arg2 = (Dali::Handle *)jarg2;
35194   if (!arg2) {
35195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
35196     return 0;
35197   }
35198   if (!jarg3) {
35199     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
35200     return 0;
35201   }
35202   std::string arg3_str(jarg3);
35203   arg3 = &arg3_str;
35204   {
35205     try {
35206       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
35207     } CALL_CATCH_EXCEPTION(0);
35208   }
35209
35210   jresult = result;
35211
35212   //argout typemap for const std::string&
35213
35214   return jresult;
35215 }
35216
35217
35218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
35219   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
35220   Dali::Actor arg2 ;
35221   Dali::Actor *argp2 ;
35222
35223   arg1 = (Dali::Toolkit::Builder *)jarg1;
35224   argp2 = (Dali::Actor *)jarg2;
35225   if (!argp2) {
35226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
35227     return ;
35228   }
35229   arg2 = *argp2;
35230   {
35231     try {
35232       (arg1)->AddActors(arg2);
35233     } CALL_CATCH_EXCEPTION();
35234   }
35235
35236 }
35237
35238
35239 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
35240   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
35241   std::string *arg2 = 0 ;
35242   Dali::Actor arg3 ;
35243   Dali::Actor *argp3 ;
35244
35245   arg1 = (Dali::Toolkit::Builder *)jarg1;
35246   if (!jarg2) {
35247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
35248     return ;
35249   }
35250   std::string arg2_str(jarg2);
35251   arg2 = &arg2_str;
35252   argp3 = (Dali::Actor *)jarg3;
35253   if (!argp3) {
35254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
35255     return ;
35256   }
35257   arg3 = *argp3;
35258   {
35259     try {
35260       (arg1)->AddActors((std::string const &)*arg2,arg3);
35261     } CALL_CATCH_EXCEPTION();
35262   }
35263
35264
35265   //argout typemap for const std::string&
35266
35267 }
35268
35269
35270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
35271   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
35272   std::string *arg2 = 0 ;
35273
35274   arg1 = (Dali::Toolkit::Builder *)jarg1;
35275   if (!jarg2) {
35276     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
35277     return ;
35278   }
35279   std::string arg2_str(jarg2);
35280   arg2 = &arg2_str;
35281   {
35282     try {
35283       (arg1)->CreateRenderTask((std::string const &)*arg2);
35284     } CALL_CATCH_EXCEPTION();
35285   }
35286
35287
35288   //argout typemap for const std::string&
35289
35290 }
35291
35292
35293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
35294   void * jresult ;
35295   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
35296   std::string *arg2 = 0 ;
35297   Dali::Path 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)->GetPath((std::string const &)*arg2);
35309     } CALL_CATCH_EXCEPTION(0);
35310   }
35311
35312   jresult = new Dali::Path((const Dali::Path &)result);
35313
35314   //argout typemap for const std::string&
35315
35316   return jresult;
35317 }
35318
35319
35320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
35321   void * jresult ;
35322   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
35323   std::string *arg2 = 0 ;
35324   Dali::PathConstrainer result;
35325
35326   arg1 = (Dali::Toolkit::Builder *)jarg1;
35327   if (!jarg2) {
35328     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
35329     return 0;
35330   }
35331   std::string arg2_str(jarg2);
35332   arg2 = &arg2_str;
35333   {
35334     try {
35335       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
35336     } CALL_CATCH_EXCEPTION(0);
35337   }
35338
35339   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
35340
35341   //argout typemap for const std::string&
35342
35343   return jresult;
35344 }
35345
35346
35347 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
35348   void * jresult ;
35349   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
35350   std::string *arg2 = 0 ;
35351   Dali::LinearConstrainer result;
35352
35353   arg1 = (Dali::Toolkit::Builder *)jarg1;
35354   if (!jarg2) {
35355     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
35356     return 0;
35357   }
35358   std::string arg2_str(jarg2);
35359   arg2 = &arg2_str;
35360   {
35361     try {
35362       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
35363     } CALL_CATCH_EXCEPTION(0);
35364   }
35365
35366   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
35367
35368   //argout typemap for const std::string&
35369
35370   return jresult;
35371 }
35372
35373
35374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
35375   void * jresult ;
35376   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
35377   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
35378
35379   arg1 = (Dali::Toolkit::Builder *)jarg1;
35380   {
35381     try {
35382       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
35383     } CALL_CATCH_EXCEPTION(0);
35384   }
35385
35386   jresult = (void *)result;
35387   return jresult;
35388 }
35389
35390
35391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
35392   void * jresult ;
35393   Dali::Toolkit::TransitionData *result = 0 ;
35394
35395   {
35396     try {
35397       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
35398     } CALL_CATCH_EXCEPTION(0);
35399   }
35400
35401   jresult = (void *)result;
35402   return jresult;
35403 }
35404
35405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
35406   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
35407
35408   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
35409   {
35410     try {
35411       delete arg1;
35412     } CALL_CATCH_EXCEPTION();
35413   }
35414
35415 }
35416
35417
35418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
35419   void * jresult ;
35420   Dali::Property::Map *arg1 = 0 ;
35421   Dali::Toolkit::TransitionData result;
35422
35423   arg1 = (Dali::Property::Map *)jarg1;
35424   if (!arg1) {
35425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
35426     return 0;
35427   }
35428   {
35429     try {
35430       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
35431     } CALL_CATCH_EXCEPTION(0);
35432   }
35433
35434   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
35435   return jresult;
35436 }
35437
35438
35439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
35440   void * jresult ;
35441   Dali::Property::Array *arg1 = 0 ;
35442   Dali::Toolkit::TransitionData result;
35443
35444   arg1 = (Dali::Property::Array *)jarg1;
35445   if (!arg1) {
35446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
35447     return 0;
35448   }
35449   {
35450     try {
35451       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
35452     } CALL_CATCH_EXCEPTION(0);
35453   }
35454
35455   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
35456   return jresult;
35457 }
35458
35459
35460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
35461   void * jresult ;
35462   Dali::BaseHandle arg1 ;
35463   Dali::BaseHandle *argp1 ;
35464   Dali::Toolkit::TransitionData result;
35465
35466   argp1 = (Dali::BaseHandle *)jarg1;
35467   if (!argp1) {
35468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
35469     return 0;
35470   }
35471   arg1 = *argp1;
35472   {
35473     try {
35474       result = Dali::Toolkit::TransitionData::DownCast(arg1);
35475     } CALL_CATCH_EXCEPTION(0);
35476   }
35477
35478   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
35479   return jresult;
35480 }
35481
35482
35483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
35484   void * jresult ;
35485   Dali::Toolkit::TransitionData *arg1 = 0 ;
35486   Dali::Toolkit::TransitionData *result = 0 ;
35487
35488   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
35489   if (!arg1) {
35490     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
35491     return 0;
35492   }
35493   {
35494     try {
35495       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
35496     } CALL_CATCH_EXCEPTION(0);
35497   }
35498
35499   jresult = (void *)result;
35500   return jresult;
35501 }
35502
35503
35504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
35505   void * jresult ;
35506   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
35507   Dali::Toolkit::TransitionData *arg2 = 0 ;
35508   Dali::Toolkit::TransitionData *result = 0 ;
35509
35510   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
35511   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
35512   if (!arg2) {
35513     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
35514     return 0;
35515   }
35516   {
35517     try {
35518       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
35519     } CALL_CATCH_EXCEPTION(0);
35520   }
35521
35522   jresult = (void *)result;
35523   return jresult;
35524 }
35525
35526
35527 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
35528   unsigned long jresult ;
35529   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
35530   size_t result;
35531
35532   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
35533   {
35534     try {
35535       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
35536     } CALL_CATCH_EXCEPTION(0);
35537   }
35538
35539   jresult = (unsigned long)result;
35540   return jresult;
35541 }
35542
35543
35544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
35545   void * jresult ;
35546   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
35547   size_t arg2 ;
35548   Dali::Property::Map result;
35549
35550   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
35551   arg2 = (size_t)jarg2;
35552   {
35553     try {
35554       result = (arg1)->GetAnimatorAt(arg2);
35555     } CALL_CATCH_EXCEPTION(0);
35556   }
35557
35558   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
35559   return jresult;
35560 }
35561
35562
35563 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
35564   int jresult ;
35565   int result;
35566
35567   {
35568     try {
35569       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
35570     } CALL_CATCH_EXCEPTION(0);
35571   }
35572
35573   jresult = (int)result;
35574   return jresult;
35575 }
35576
35577
35578 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() {
35579   int jresult ;
35580   int result;
35581
35582   {
35583     try {
35584       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
35585     } CALL_CATCH_EXCEPTION(0);
35586   }
35587
35588   jresult = (int)result;
35589   return jresult;
35590 }
35591
35592
35593 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() {
35594   int jresult ;
35595   int result;
35596
35597   {
35598     try {
35599       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
35600     } CALL_CATCH_EXCEPTION(0);
35601   }
35602
35603   jresult = (int)result;
35604   return jresult;
35605 }
35606
35607
35608 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() {
35609   int jresult ;
35610   int result;
35611
35612   {
35613     try {
35614       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
35615     } CALL_CATCH_EXCEPTION(0);
35616   }
35617
35618   jresult = (int)result;
35619   return jresult;
35620 }
35621
35622
35623 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() {
35624   int jresult ;
35625   int result;
35626
35627   {
35628     try {
35629       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
35630     } CALL_CATCH_EXCEPTION(0);
35631   }
35632
35633   jresult = (int)result;
35634   return jresult;
35635 }
35636
35637
35638 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() {
35639   int jresult ;
35640   int result;
35641
35642   {
35643     try {
35644       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
35645     } CALL_CATCH_EXCEPTION(0);
35646   }
35647
35648   jresult = (int)result;
35649   return jresult;
35650 }
35651
35652
35653 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
35654   int jresult ;
35655   int result;
35656
35657   {
35658     try {
35659       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
35660     } CALL_CATCH_EXCEPTION(0);
35661   }
35662
35663   jresult = (int)result;
35664   return jresult;
35665 }
35666
35667
35668 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
35669   int jresult ;
35670   int result;
35671
35672   {
35673     try {
35674       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
35675     } CALL_CATCH_EXCEPTION(0);
35676   }
35677
35678   jresult = (int)result;
35679   return jresult;
35680 }
35681
35682
35683 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
35684   int jresult ;
35685   int result;
35686
35687   {
35688     try {
35689       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
35690     } CALL_CATCH_EXCEPTION(0);
35691   }
35692
35693   jresult = (int)result;
35694   return jresult;
35695 }
35696
35697
35698 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
35699   int jresult ;
35700   int result;
35701
35702   {
35703     try {
35704       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
35705     } CALL_CATCH_EXCEPTION(0);
35706   }
35707
35708   jresult = (int)result;
35709   return jresult;
35710 }
35711
35712
35713 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
35714   int jresult ;
35715   int result;
35716
35717   {
35718     try {
35719       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
35720     } CALL_CATCH_EXCEPTION(0);
35721   }
35722
35723   jresult = (int)result;
35724   return jresult;
35725 }
35726
35727
35728 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() {
35729   int jresult ;
35730   int result;
35731
35732   {
35733     try {
35734       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
35735     } CALL_CATCH_EXCEPTION(0);
35736   }
35737
35738   jresult = (int)result;
35739   return jresult;
35740 }
35741
35742
35743 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
35744   int jresult ;
35745   int result;
35746
35747   {
35748     try {
35749       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
35750     } CALL_CATCH_EXCEPTION(0);
35751   }
35752
35753   jresult = (int)result;
35754   return jresult;
35755 }
35756
35757
35758 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() {
35759   int jresult ;
35760   int result;
35761
35762   {
35763     try {
35764       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
35765     } CALL_CATCH_EXCEPTION(0);
35766   }
35767
35768   jresult = (int)result;
35769   return jresult;
35770 }
35771
35772
35773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
35774   void * jresult ;
35775   Dali::Toolkit::Control result;
35776
35777   {
35778     try {
35779       result = Dali::Toolkit::Internal::Control::New();
35780     } CALL_CATCH_EXCEPTION(0);
35781   }
35782
35783   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
35784   return jresult;
35785 }
35786
35787
35788 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
35789   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
35790   std::string *arg2 = 0 ;
35791
35792   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
35793   if (!jarg2) {
35794     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
35795     return ;
35796   }
35797   std::string arg2_str(jarg2);
35798   arg2 = &arg2_str;
35799   {
35800     try {
35801       (arg1)->SetStyleName((std::string const &)*arg2);
35802     } CALL_CATCH_EXCEPTION();
35803   }
35804
35805
35806   //argout typemap for const std::string&
35807
35808 }
35809
35810
35811 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
35812   char * jresult ;
35813   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
35814   std::string *result = 0 ;
35815
35816   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
35817   {
35818     try {
35819       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
35820     } CALL_CATCH_EXCEPTION(0);
35821   }
35822
35823   jresult = SWIG_csharp_string_callback(result->c_str());
35824   return jresult;
35825 }
35826
35827
35828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
35829   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
35830   Dali::Vector4 *arg2 = 0 ;
35831
35832   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
35833   arg2 = (Dali::Vector4 *)jarg2;
35834   if (!arg2) {
35835     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
35836     return ;
35837   }
35838   {
35839     try {
35840       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
35841     } CALL_CATCH_EXCEPTION();
35842   }
35843
35844 }
35845
35846
35847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
35848   void * jresult ;
35849   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
35850   Dali::Vector4 result;
35851
35852   arg1 = (Dali::Handle *)jarg1;
35853   {
35854     try {
35855       Property::Map* resultMap = ((arg1)->GetProperty( Control::Property::BACKGROUND )).GetMap();
35856       if (resultMap)
35857       {
35858         Dali::Property::Value* type = resultMap->Find( Toolkit::Visual::Property::TYPE );
35859         if(type && type->Get<int>() == Visual::COLOR )
35860         {
35861           Dali::Property::Value* value = resultMap->Find( ColorVisual::Property::MIX_COLOR );
35862           if (value)
35863           {
35864             result = value->Get<Vector4>();
35865           }
35866         }
35867       }
35868     } CALL_CATCH_EXCEPTION(0);
35869   }
35870
35871   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
35872   return jresult;
35873 }
35874
35875
35876 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
35877   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
35878   Dali::Property::Map *arg2 = 0 ;
35879
35880   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
35881   arg2 = (Dali::Property::Map *)jarg2;
35882   if (!arg2) {
35883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
35884     return ;
35885   }
35886   {
35887     try {
35888       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
35889     } CALL_CATCH_EXCEPTION();
35890   }
35891
35892 }
35893
35894
35895 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
35896   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
35897
35898   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
35899   {
35900     try {
35901       (arg1)->ClearBackground();
35902     } CALL_CATCH_EXCEPTION();
35903   }
35904
35905 }
35906
35907
35908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
35909   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
35910   Dali::Gesture::Type arg2 ;
35911
35912   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
35913   arg2 = (Dali::Gesture::Type)jarg2;
35914   {
35915     try {
35916       (arg1)->EnableGestureDetection(arg2);
35917     } CALL_CATCH_EXCEPTION();
35918   }
35919
35920 }
35921
35922
35923 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
35924   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
35925   Dali::Gesture::Type arg2 ;
35926
35927   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
35928   arg2 = (Dali::Gesture::Type)jarg2;
35929   {
35930     try {
35931       (arg1)->DisableGestureDetection(arg2);
35932     } CALL_CATCH_EXCEPTION();
35933   }
35934
35935 }
35936
35937
35938 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
35939   void * jresult ;
35940   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
35941   Dali::PinchGestureDetector result;
35942
35943   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
35944   {
35945     try {
35946       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
35947     } CALL_CATCH_EXCEPTION(0);
35948   }
35949
35950   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
35951   return jresult;
35952 }
35953
35954
35955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
35956   void * jresult ;
35957   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
35958   Dali::PanGestureDetector result;
35959
35960   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
35961   {
35962     try {
35963       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
35964     } CALL_CATCH_EXCEPTION(0);
35965   }
35966
35967   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
35968   return jresult;
35969 }
35970
35971
35972 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
35973   void * jresult ;
35974   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
35975   Dali::TapGestureDetector result;
35976
35977   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
35978   {
35979     try {
35980       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
35981     } CALL_CATCH_EXCEPTION(0);
35982   }
35983
35984   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
35985   return jresult;
35986 }
35987
35988
35989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
35990   void * jresult ;
35991   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
35992   Dali::LongPressGestureDetector result;
35993
35994   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
35995   {
35996     try {
35997       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
35998     } CALL_CATCH_EXCEPTION(0);
35999   }
36000
36001   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
36002   return jresult;
36003 }
36004
36005
36006 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, unsigned int jarg2) {
36007   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36008   bool arg2 ;
36009
36010   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36011   arg2 = jarg2 ? true : false;
36012   {
36013     try {
36014       (arg1)->SetKeyboardNavigationSupport(arg2);
36015     } CALL_CATCH_EXCEPTION();
36016   }
36017
36018 }
36019
36020
36021 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
36022   unsigned int jresult ;
36023   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36024   bool result;
36025
36026   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36027   {
36028     try {
36029       result = (bool)(arg1)->IsKeyboardNavigationSupported();
36030     } CALL_CATCH_EXCEPTION(0);
36031   }
36032
36033   jresult = result;
36034   return jresult;
36035 }
36036
36037
36038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
36039   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36040
36041   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36042   {
36043     try {
36044       (arg1)->SetKeyInputFocus();
36045     } CALL_CATCH_EXCEPTION();
36046   }
36047
36048 }
36049
36050
36051 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
36052   unsigned int jresult ;
36053   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36054   bool result;
36055
36056   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36057   {
36058     try {
36059       result = (bool)(arg1)->HasKeyInputFocus();
36060     } CALL_CATCH_EXCEPTION(0);
36061   }
36062
36063   jresult = result;
36064   return jresult;
36065 }
36066
36067
36068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
36069   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36070
36071   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36072   {
36073     try {
36074       (arg1)->ClearKeyInputFocus();
36075     } CALL_CATCH_EXCEPTION();
36076   }
36077
36078 }
36079
36080
36081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, unsigned int jarg2) {
36082   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36083   bool arg2 ;
36084
36085   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36086   arg2 = jarg2 ? true : false;
36087   {
36088     try {
36089       (arg1)->SetAsKeyboardFocusGroup(arg2);
36090     } CALL_CATCH_EXCEPTION();
36091   }
36092
36093 }
36094
36095
36096 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
36097   unsigned int jresult ;
36098   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36099   bool result;
36100
36101   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36102   {
36103     try {
36104       result = (bool)(arg1)->IsKeyboardFocusGroup();
36105     } CALL_CATCH_EXCEPTION(0);
36106   }
36107
36108   jresult = result;
36109   return jresult;
36110 }
36111
36112
36113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
36114   void * jresult ;
36115   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36116   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
36117
36118   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36119   {
36120     try {
36121       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
36122     } CALL_CATCH_EXCEPTION(0);
36123   }
36124
36125   jresult = (void *)result;
36126   return jresult;
36127 }
36128
36129
36130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
36131   void * jresult ;
36132   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36133   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
36134
36135   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36136   {
36137     try {
36138       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
36139     } CALL_CATCH_EXCEPTION(0);
36140   }
36141
36142   jresult = (void *)result;
36143   return jresult;
36144 }
36145
36146
36147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
36148   void * jresult ;
36149   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36150   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
36151
36152   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36153   {
36154     try {
36155       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
36156     } CALL_CATCH_EXCEPTION(0);
36157   }
36158
36159   jresult = (void *)result;
36160   return jresult;
36161 }
36162
36163
36164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneConnection(void * jarg1, int jarg2) {
36165   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36166   int arg2 ;
36167   SwigDirector_ViewImpl *darg = 0;
36168
36169   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36170   arg2 = (int)jarg2;
36171   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36172   if(!darg) {
36173     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36174     return;
36175   }
36176   {
36177     try {
36178       if(darg) {
36179         (darg)->OnSceneConnection(arg2);
36180       }
36181     } CALL_CATCH_EXCEPTION();
36182   }
36183
36184 }
36185
36186
36187 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
36188   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36189   int arg2 ;
36190   SwigDirector_ViewImpl *darg = 0;
36191
36192   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36193   arg2 = (int)jarg2;
36194   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36195   if(!darg) {
36196     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36197     return;
36198   }
36199   {
36200     try {
36201       if(darg) {
36202         (darg)->OnSceneConnectionSwigPublic(arg2);
36203       }
36204     } CALL_CATCH_EXCEPTION();
36205   }
36206
36207 }
36208
36209
36210 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneDisconnection(void * jarg1) {
36211   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36212   SwigDirector_ViewImpl *darg = 0;
36213
36214   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36215   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36216   if(!darg) {
36217     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36218     return;
36219   }
36220   {
36221     try {
36222       if(darg) {
36223         (darg)->OnSceneDisconnection();
36224       }
36225     } CALL_CATCH_EXCEPTION();
36226   }
36227
36228 }
36229
36230
36231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneDisconnectionSwigExplicitViewImpl(void * jarg1) {
36232   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36233   SwigDirector_ViewImpl *darg = 0;
36234
36235   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
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)->OnSceneDisconnectionSwigPublic();
36245       }
36246     } CALL_CATCH_EXCEPTION();
36247   }
36248
36249 }
36250
36251
36252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(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)->OnChildAdd(*arg2);
36272       }
36273     } CALL_CATCH_EXCEPTION();
36274   }
36275
36276 }
36277
36278
36279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(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)->OnChildAddSwigPublic(*arg2);
36299       }
36300     } CALL_CATCH_EXCEPTION();
36301   }
36302
36303 }
36304
36305
36306 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
36307   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36308   Dali::Actor *arg2 = 0 ;
36309   SwigDirector_ViewImpl *darg = 0;
36310
36311   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36312   arg2 = (Dali::Actor *)jarg2;
36313   if (!arg2) {
36314     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
36315     return ;
36316   }
36317   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36318   if(!darg) {
36319     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36320     return;
36321   }
36322   {
36323     try {
36324       if(darg) {
36325         (darg)->OnChildRemove(*arg2);
36326       }
36327     } CALL_CATCH_EXCEPTION();
36328   }
36329
36330 }
36331
36332
36333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
36334   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36335   Dali::Actor *arg2 = 0 ;
36336   SwigDirector_ViewImpl *darg = 0;
36337
36338   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36339   arg2 = (Dali::Actor *)jarg2;
36340   if (!arg2) {
36341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
36342     return ;
36343   }
36344   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36345   if(!darg) {
36346     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36347     return;
36348   }
36349   {
36350     try {
36351       if(darg) {
36352         (darg)->OnChildRemoveSwigPublic(*arg2);
36353       }
36354     } CALL_CATCH_EXCEPTION();
36355   }
36356
36357 }
36358
36359
36360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
36361   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36362   Dali::Property::Index arg2 ;
36363   Dali::Property::Value arg3 ;
36364   Dali::Property::Value *argp3 ;
36365   SwigDirector_ViewImpl *darg = 0;
36366
36367   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36368   arg2 = (Dali::Property::Index)jarg2;
36369   argp3 = (Dali::Property::Value *)jarg3;
36370   if (!argp3) {
36371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
36372     return ;
36373   }
36374   arg3 = *argp3;
36375   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36376   if (!darg) {
36377     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36378     return;
36379   }
36380   {
36381     try {
36382       (darg)->OnPropertySet(arg2,arg3);
36383     } CALL_CATCH_EXCEPTION();
36384   }
36385
36386 }
36387
36388
36389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
36390   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36391   Dali::Vector3 *arg2 = 0 ;
36392   SwigDirector_ViewImpl *darg = 0;
36393
36394   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36395   arg2 = (Dali::Vector3 *)jarg2;
36396   if (!arg2) {
36397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
36398     return ;
36399   }
36400   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36401   if (!darg) {
36402     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36403     return;
36404   }
36405   {
36406     try {
36407       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
36408     } CALL_CATCH_EXCEPTION();
36409   }
36410
36411 }
36412
36413
36414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
36415   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36416   Dali::Vector3 *arg2 = 0 ;
36417   SwigDirector_ViewImpl *darg = 0;
36418
36419   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36420   arg2 = (Dali::Vector3 *)jarg2;
36421   if (!arg2) {
36422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
36423     return ;
36424   }
36425   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36426   if (!darg) {
36427     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36428     return;
36429   }
36430   {
36431     try {
36432       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
36433     } CALL_CATCH_EXCEPTION();
36434   }
36435
36436 }
36437
36438
36439 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
36440   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36441   Dali::Animation *arg2 = 0 ;
36442   Dali::Vector3 *arg3 = 0 ;
36443   SwigDirector_ViewImpl *darg = 0;
36444
36445   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36446   arg2 = (Dali::Animation *)jarg2;
36447   if (!arg2) {
36448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
36449     return ;
36450   }
36451   arg3 = (Dali::Vector3 *)jarg3;
36452   if (!arg3) {
36453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
36454     return ;
36455   }
36456   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36457   if (!darg) {
36458     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36459     return;
36460   }
36461   {
36462     try {
36463       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
36464     } CALL_CATCH_EXCEPTION();
36465   }
36466
36467 }
36468
36469
36470 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
36471   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36472   Dali::Animation *arg2 = 0 ;
36473   Dali::Vector3 *arg3 = 0 ;
36474   SwigDirector_ViewImpl *darg = 0;
36475
36476   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36477   arg2 = (Dali::Animation *)jarg2;
36478   if (!arg2) {
36479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
36480     return ;
36481   }
36482   arg3 = (Dali::Vector3 *)jarg3;
36483   if (!arg3) {
36484     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
36485     return ;
36486   }
36487   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36488   if (!darg) {
36489     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36490     return;
36491   }
36492   {
36493     try {
36494       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
36495     } CALL_CATCH_EXCEPTION();
36496   }
36497 }
36498
36499
36500 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEvent(void * jarg1, void * jarg2) {
36501   unsigned int jresult ;
36502   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36503   Dali::HoverEvent *arg2 = 0 ;
36504   SwigDirector_ViewImpl *darg = 0;
36505   bool result;
36506
36507   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36508   arg2 = (Dali::HoverEvent *)jarg2;
36509   if (!arg2) {
36510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
36511     return 0;
36512   }
36513   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36514   if (!darg) {
36515     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36516     return 0;
36517   }
36518   {
36519     try {
36520       result = (bool)(darg)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
36521     } CALL_CATCH_EXCEPTION(0);
36522   }
36523
36524   jresult = result;
36525   return jresult;
36526 }
36527
36528
36529 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
36530   unsigned int jresult ;
36531   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36532   Dali::HoverEvent *arg2 = 0 ;
36533   SwigDirector_ViewImpl *darg = 0;
36534   bool result;
36535
36536   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36537   arg2 = (Dali::HoverEvent *)jarg2;
36538   if (!arg2) {
36539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
36540     return 0;
36541   }
36542   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36543   if (!darg) {
36544     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36545     return 0;
36546   }
36547   {
36548     try {
36549       result = (bool)(darg)->OnHoverEventSwigPublic((Dali::HoverEvent const &)*arg2);
36550     } CALL_CATCH_EXCEPTION(0);
36551   }
36552
36553   jresult = result;
36554   return jresult;
36555 }
36556
36557
36558 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
36559   unsigned int jresult ;
36560   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36561   Dali::KeyEvent *arg2 = 0 ;
36562   SwigDirector_ViewImpl *darg = 0;
36563   bool result;
36564
36565   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36566   arg2 = (Dali::KeyEvent *)jarg2;
36567   if (!arg2) {
36568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
36569     return 0;
36570   }
36571   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36572   if (!darg) {
36573     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36574     return 0;
36575   }
36576   {
36577     try {
36578       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
36579     } CALL_CATCH_EXCEPTION(0);
36580   }
36581
36582   jresult = result;
36583   return jresult;
36584 }
36585
36586
36587 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
36588   unsigned int jresult ;
36589   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36590   Dali::KeyEvent *arg2 = 0 ;
36591   SwigDirector_ViewImpl *darg = 0;
36592   bool result;
36593
36594   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36595   arg2 = (Dali::KeyEvent *)jarg2;
36596   if (!arg2) {
36597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
36598     return 0;
36599   }
36600   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36601   if (!darg) {
36602     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36603     return 0;
36604   }
36605   {
36606     try {
36607       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
36608     } CALL_CATCH_EXCEPTION(0);
36609   }
36610
36611   jresult = result;
36612   return jresult;
36613 }
36614
36615
36616 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEvent(void * jarg1, void * jarg2) {
36617   unsigned int jresult ;
36618   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36619   Dali::WheelEvent *arg2 = 0 ;
36620   SwigDirector_ViewImpl *darg = 0;
36621   bool result;
36622
36623   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36624   arg2 = (Dali::WheelEvent *)jarg2;
36625   if (!arg2) {
36626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
36627     return 0;
36628   }
36629   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36630   if (!darg) {
36631     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36632     return 0;
36633   }
36634   {
36635     try {
36636       result = (bool)(darg)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
36637     } CALL_CATCH_EXCEPTION(0);
36638   }
36639
36640   jresult = result;
36641   return jresult;
36642 }
36643
36644
36645 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
36646   unsigned int jresult ;
36647   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36648   Dali::WheelEvent *arg2 = 0 ;
36649   SwigDirector_ViewImpl *darg = 0;
36650   bool result;
36651
36652   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36653   arg2 = (Dali::WheelEvent *)jarg2;
36654   if (!arg2) {
36655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
36656     return 0;
36657   }
36658   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36659   if (!darg) {
36660     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36661     return 0;
36662   }
36663   {
36664     try {
36665       result = (bool)(darg)->OnWheelEventSwigPublic((Dali::WheelEvent const &)*arg2);
36666     } CALL_CATCH_EXCEPTION(0);
36667   }
36668
36669   jresult = result;
36670   return jresult;
36671 }
36672
36673
36674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
36675   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36676   Dali::Vector2 *arg2 = 0 ;
36677   Dali::RelayoutContainer *arg3 = 0 ;
36678   SwigDirector_ViewImpl *darg = 0;
36679
36680   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36681   arg2 = (Dali::Vector2 *)jarg2;
36682   if (!arg2) {
36683     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36684     return ;
36685   }
36686   arg3 = (Dali::RelayoutContainer *)jarg3;
36687   if (!arg3) {
36688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
36689     return ;
36690   }
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)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
36699     } CALL_CATCH_EXCEPTION();
36700   }
36701
36702 }
36703
36704
36705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
36706   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36707   Dali::Vector2 *arg2 = 0 ;
36708   Dali::RelayoutContainer *arg3 = 0 ;
36709   SwigDirector_ViewImpl *darg = 0;
36710
36711   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36712   arg2 = (Dali::Vector2 *)jarg2;
36713   if (!arg2) {
36714     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36715     return ;
36716   }
36717   arg3 = (Dali::RelayoutContainer *)jarg3;
36718   if (!arg3) {
36719     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
36720     return ;
36721   }
36722   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36723   if (!darg) {
36724     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36725     return;
36726   }
36727   {
36728     try {
36729       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
36730     } CALL_CATCH_EXCEPTION();
36731   }
36732
36733 }
36734
36735
36736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
36737   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36738   Dali::ResizePolicy::Type arg2 ;
36739   Dali::Dimension::Type arg3 ;
36740   SwigDirector_ViewImpl *darg = 0;
36741
36742   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36743   arg2 = (Dali::ResizePolicy::Type)jarg2;
36744   arg3 = (Dali::Dimension::Type)jarg3;
36745   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36746   if (!darg) {
36747     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36748     return;
36749   }
36750   {
36751     try {
36752       (darg)->OnSetResizePolicy(arg2,arg3);
36753     } CALL_CATCH_EXCEPTION();
36754   }
36755
36756 }
36757
36758
36759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
36760   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36761   Dali::ResizePolicy::Type arg2 ;
36762   Dali::Dimension::Type arg3 ;
36763   SwigDirector_ViewImpl *darg = 0;
36764
36765   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36766   arg2 = (Dali::ResizePolicy::Type)jarg2;
36767   arg3 = (Dali::Dimension::Type)jarg3;
36768   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36769   if (!darg) {
36770     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36771     return;
36772   }
36773   {
36774     try {
36775       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
36776     } CALL_CATCH_EXCEPTION();
36777   }
36778
36779 }
36780
36781
36782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
36783   void * jresult ;
36784   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36785   SwigDirector_ViewImpl *darg = 0;
36786   Dali::Vector3 result;
36787
36788   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
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 = (darg)->GetNaturalSize();
36797     } CALL_CATCH_EXCEPTION(0);
36798   }
36799
36800   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
36801   return jresult;
36802 }
36803
36804
36805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
36806   void * jresult ;
36807   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36808   SwigDirector_ViewImpl *darg = 0;
36809   Dali::Vector3 result;
36810
36811   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36812   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36813   if (!darg) {
36814     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36815     return 0;
36816   }
36817   {
36818     try {
36819       result = (darg)->GetNaturalSizeSwigPublic();
36820     } CALL_CATCH_EXCEPTION(0);
36821   }
36822
36823   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
36824   return jresult;
36825 }
36826
36827
36828 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
36829   float jresult ;
36830   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36831   Dali::Actor *arg2 = 0 ;
36832   Dali::Dimension::Type arg3 ;
36833   SwigDirector_ViewImpl *darg = 0;
36834   float result;
36835
36836   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36837   arg2 = (Dali::Actor *)jarg2;
36838   if (!arg2) {
36839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
36840     return 0;
36841   }
36842   arg3 = (Dali::Dimension::Type)jarg3;
36843   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36844   if (!darg) {
36845     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36846     return 0;
36847   }
36848   {
36849     try {
36850       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
36851     } CALL_CATCH_EXCEPTION(0);
36852   }
36853
36854   jresult = result;
36855   return jresult;
36856 }
36857
36858
36859 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
36860   float jresult ;
36861   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36862   Dali::Actor *arg2 = 0 ;
36863   Dali::Dimension::Type arg3 ;
36864   SwigDirector_ViewImpl *darg = 0;
36865   float result;
36866
36867   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36868   arg2 = (Dali::Actor *)jarg2;
36869   if (!arg2) {
36870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
36871     return 0;
36872   }
36873   arg3 = (Dali::Dimension::Type)jarg3;
36874   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36875   if (!darg) {
36876     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36877     return 0;
36878   }
36879   {
36880     try {
36881       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
36882     } CALL_CATCH_EXCEPTION(0);
36883   }
36884
36885   jresult = result;
36886   return jresult;
36887 }
36888
36889
36890 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
36891   float jresult ;
36892   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36893   float arg2 ;
36894   SwigDirector_ViewImpl *darg = 0;
36895   float result;
36896
36897   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36898   arg2 = (float)jarg2;
36899   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36900   if (!darg) {
36901     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36902     return 0;
36903   }
36904   {
36905     try {
36906       result = (float)(darg)->GetHeightForWidth(arg2);
36907     } CALL_CATCH_EXCEPTION(0);
36908   }
36909
36910   jresult = result;
36911   return jresult;
36912 }
36913
36914
36915 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
36916   float jresult ;
36917   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36918   float arg2 ;
36919   SwigDirector_ViewImpl *darg = 0;
36920   float result;
36921
36922   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36923   arg2 = (float)jarg2;
36924   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36925   if (!darg) {
36926     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36927     return 0;
36928   }
36929   {
36930     try {
36931       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
36932     } CALL_CATCH_EXCEPTION(0);
36933   }
36934
36935   jresult = result;
36936   return jresult;
36937 }
36938
36939
36940 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
36941   float jresult ;
36942   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36943   float arg2 ;
36944   SwigDirector_ViewImpl *darg = 0;
36945   float result;
36946
36947   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36948   arg2 = (float)jarg2;
36949   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36950   if (!darg) {
36951     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36952     return 0;
36953   }
36954   {
36955     try {
36956       result = (float)(darg)->GetWidthForHeight(arg2);
36957     } CALL_CATCH_EXCEPTION(0);
36958   }
36959
36960   jresult = result;
36961   return jresult;
36962 }
36963
36964
36965 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
36966   float jresult ;
36967   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36968   float arg2 ;
36969   SwigDirector_ViewImpl *darg = 0;
36970   float result;
36971
36972   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36973   arg2 = (float)jarg2;
36974   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36975   if (!darg) {
36976     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36977     return 0;
36978   }
36979   {
36980     try {
36981       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
36982     } CALL_CATCH_EXCEPTION(0);
36983   }
36984
36985   jresult = result;
36986   return jresult;
36987 }
36988
36989
36990 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
36991   unsigned int jresult ;
36992   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36993   Dali::Dimension::Type arg2 ;
36994   SwigDirector_ViewImpl *darg = 0;
36995   bool result;
36996
36997   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36998   arg2 = (Dali::Dimension::Type)jarg2;
36999   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
37000   if (!darg) {
37001     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
37002     return 0;
37003   }
37004   {
37005     try {
37006       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
37007     } CALL_CATCH_EXCEPTION(0);
37008   }
37009
37010   jresult = result;
37011   return jresult;
37012 }
37013
37014
37015 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
37016   unsigned int jresult ;
37017   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37018   Dali::Dimension::Type arg2 ;
37019   SwigDirector_ViewImpl *darg = 0;
37020   bool result;
37021
37022   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37023   arg2 = (Dali::Dimension::Type)jarg2;
37024   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
37025   if (!darg) {
37026     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
37027     return 0;
37028   }
37029   {
37030     try {
37031       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
37032     } CALL_CATCH_EXCEPTION(0);
37033   }
37034
37035   jresult = result;
37036   return jresult;
37037 }
37038
37039
37040 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
37041   unsigned int jresult ;
37042   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37043   SwigDirector_ViewImpl *darg = 0;
37044   bool result;
37045
37046   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37047   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
37048   if (!darg) {
37049     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
37050     return 0;
37051   }
37052   {
37053     try {
37054       result = (bool)(darg)->RelayoutDependentOnChildren();
37055     } CALL_CATCH_EXCEPTION(0);
37056   }
37057
37058   jresult = result;
37059   return jresult;
37060 }
37061
37062
37063 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
37064   unsigned int jresult ;
37065   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37066   SwigDirector_ViewImpl *darg = 0;
37067   bool result;
37068
37069   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37070   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
37071   if (!darg) {
37072     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
37073     return 0;
37074   }
37075   {
37076     try {
37077       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
37078     } CALL_CATCH_EXCEPTION(0);
37079   }
37080
37081   jresult = result;
37082   return jresult;
37083 }
37084
37085
37086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
37087   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37088   Dali::Dimension::Type arg2 ;
37089   SwigDirector_ViewImpl *darg = 0;
37090
37091   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37092   arg2 = (Dali::Dimension::Type)jarg2;
37093   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
37094   if (!darg) {
37095     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
37096     return;
37097   }
37098   {
37099     try {
37100       (darg)->OnCalculateRelayoutSize(arg2);
37101     } CALL_CATCH_EXCEPTION();
37102   }
37103
37104 }
37105
37106
37107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
37108   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37109   Dali::Dimension::Type arg2 ;
37110   SwigDirector_ViewImpl *darg = 0;
37111
37112   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37113   arg2 = (Dali::Dimension::Type)jarg2;
37114   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
37115   if (!darg) {
37116     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
37117     return;
37118   }
37119   {
37120     try {
37121       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
37122     } CALL_CATCH_EXCEPTION();
37123   }
37124
37125 }
37126
37127
37128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
37129   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37130   float arg2 ;
37131   Dali::Dimension::Type arg3 ;
37132   SwigDirector_ViewImpl *darg = 0;
37133
37134   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37135   arg2 = (float)jarg2;
37136   arg3 = (Dali::Dimension::Type)jarg3;
37137   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
37138   if (!darg) {
37139     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
37140     return;
37141   }
37142   {
37143     try {
37144       (darg)->OnLayoutNegotiated(arg2,arg3);
37145     } CALL_CATCH_EXCEPTION();
37146   }
37147
37148 }
37149
37150
37151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
37152   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37153   float arg2 ;
37154   Dali::Dimension::Type arg3 ;
37155   SwigDirector_ViewImpl *darg = 0;
37156
37157   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37158   arg2 = (float)jarg2;
37159   arg3 = (Dali::Dimension::Type)jarg3;
37160   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
37161   if (!darg) {
37162     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
37163     return;
37164   }
37165   {
37166     try {
37167       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
37168     } CALL_CATCH_EXCEPTION();
37169   }
37170
37171 }
37172
37173
37174 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
37175   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37176
37177   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37178   {
37179     try {
37180       (arg1)->OnInitialize();
37181     } CALL_CATCH_EXCEPTION();
37182   }
37183
37184 }
37185
37186
37187 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
37188   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37189
37190   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37191   {
37192     try {
37193       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
37194     } CALL_CATCH_EXCEPTION();
37195   }
37196
37197 }
37198
37199
37200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
37201   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37202   Dali::Toolkit::StyleManager arg2 ;
37203   Dali::StyleChange::Type arg3 ;
37204   Dali::Toolkit::StyleManager *argp2 ;
37205
37206   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37207   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
37208   if (!argp2) {
37209     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
37210     return ;
37211   }
37212   arg2 = *argp2;
37213   arg3 = (Dali::StyleChange::Type)jarg3;
37214   {
37215     try {
37216       (arg1)->OnStyleChange(arg2,arg3);
37217     } CALL_CATCH_EXCEPTION();
37218   }
37219
37220 }
37221
37222
37223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
37224   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37225   Dali::Toolkit::StyleManager arg2 ;
37226   Dali::StyleChange::Type arg3 ;
37227   Dali::Toolkit::StyleManager *argp2 ;
37228
37229   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37230   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
37231   if (!argp2) {
37232     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
37233     return ;
37234   }
37235   arg2 = *argp2;
37236   arg3 = (Dali::StyleChange::Type)jarg3;
37237   {
37238     try {
37239       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
37240     } CALL_CATCH_EXCEPTION();
37241   }
37242
37243 }
37244
37245
37246 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
37247   unsigned int jresult ;
37248   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37249   bool result;
37250
37251   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37252   {
37253     try {
37254       result = (bool)(arg1)->OnAccessibilityActivated();
37255     } CALL_CATCH_EXCEPTION(0);
37256   }
37257
37258   jresult = result;
37259   return jresult;
37260 }
37261
37262
37263 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
37264   unsigned int jresult ;
37265   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37266   bool result;
37267
37268   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37269   {
37270     try {
37271       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
37272     } CALL_CATCH_EXCEPTION(0);
37273   }
37274
37275   jresult = result;
37276   return jresult;
37277 }
37278
37279
37280 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
37281   unsigned int jresult ;
37282   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37283   Dali::PanGesture arg2 ;
37284   Dali::PanGesture *argp2 ;
37285   bool result;
37286
37287   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37288   argp2 = (Dali::PanGesture *)jarg2;
37289   if (!argp2) {
37290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
37291     return 0;
37292   }
37293   arg2 = *argp2;
37294   {
37295     try {
37296       result = (bool)(arg1)->OnAccessibilityPan(arg2);
37297     } CALL_CATCH_EXCEPTION(0);
37298   }
37299
37300   jresult = result;
37301   return jresult;
37302 }
37303
37304
37305 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
37306   unsigned int jresult ;
37307   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37308   Dali::PanGesture arg2 ;
37309   Dali::PanGesture *argp2 ;
37310   bool result;
37311
37312   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37313   argp2 = (Dali::PanGesture *)jarg2;
37314   if (!argp2) {
37315     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
37316     return 0;
37317   }
37318   arg2 = *argp2;
37319   {
37320     try {
37321       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
37322     } CALL_CATCH_EXCEPTION(0);
37323   }
37324
37325   jresult = result;
37326   return jresult;
37327 }
37328
37329 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, unsigned int jarg2) {
37330   unsigned int jresult ;
37331   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37332   bool arg2 ;
37333   bool result;
37334
37335   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37336   arg2 = jarg2 ? true : false;
37337   {
37338     try {
37339       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
37340     } CALL_CATCH_EXCEPTION(0);
37341   }
37342
37343   jresult = result;
37344   return jresult;
37345 }
37346
37347
37348 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, unsigned int jarg2) {
37349   unsigned int jresult ;
37350   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37351   bool arg2 ;
37352   bool result;
37353
37354   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37355   arg2 = jarg2 ? true : false;
37356   {
37357     try {
37358       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
37359     } CALL_CATCH_EXCEPTION(0);
37360   }
37361
37362   jresult = result;
37363   return jresult;
37364 }
37365
37366
37367 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
37368   unsigned int jresult ;
37369   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37370   bool result;
37371
37372   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37373   {
37374     try {
37375       result = (bool)(arg1)->OnAccessibilityZoom();
37376     } CALL_CATCH_EXCEPTION(0);
37377   }
37378
37379   jresult = result;
37380   return jresult;
37381 }
37382
37383
37384 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
37385   unsigned int jresult ;
37386   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37387   bool result;
37388
37389   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37390   {
37391     try {
37392       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
37393     } CALL_CATCH_EXCEPTION(0);
37394   }
37395
37396   jresult = result;
37397   return jresult;
37398 }
37399
37400
37401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
37402   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37403
37404   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37405   {
37406     try {
37407       (arg1)->OnKeyInputFocusGained();
37408     } CALL_CATCH_EXCEPTION();
37409   }
37410
37411 }
37412
37413
37414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
37415   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37416
37417   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37418   {
37419     try {
37420       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
37421     } CALL_CATCH_EXCEPTION();
37422   }
37423
37424 }
37425
37426
37427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
37428   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37429
37430   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37431   {
37432     try {
37433       (arg1)->OnKeyInputFocusLost();
37434     } CALL_CATCH_EXCEPTION();
37435   }
37436
37437 }
37438
37439
37440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
37441   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37442
37443   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37444   {
37445     try {
37446       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
37447     } CALL_CATCH_EXCEPTION();
37448   }
37449
37450 }
37451
37452
37453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
37454   void * jresult ;
37455   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37456   Dali::Actor arg2 ;
37457   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
37458   bool arg4 ;
37459   Dali::Actor *argp2 ;
37460   Dali::Actor result;
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 0;
37467   }
37468   arg2 = *argp2;
37469   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
37470   arg4 = jarg4 ? true : false;
37471   {
37472     try {
37473       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
37474     } CALL_CATCH_EXCEPTION(0);
37475   }
37476
37477   jresult = new Dali::Actor((const Dali::Actor &)result);
37478   return jresult;
37479 }
37480
37481
37482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
37483   void * jresult ;
37484   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37485   Dali::Actor arg2 ;
37486   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
37487   bool arg4 ;
37488   Dali::Actor *argp2 ;
37489   Dali::Actor result;
37490
37491   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37492   argp2 = (Dali::Actor *)jarg2;
37493   if (!argp2) {
37494     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
37495     return 0;
37496   }
37497   arg2 = *argp2;
37498   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
37499   arg4 = jarg4 ? true : false;
37500   {
37501     try {
37502       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
37503     } CALL_CATCH_EXCEPTION(0);
37504   }
37505
37506   jresult = new Dali::Actor((const Dali::Actor &)result);
37507   return jresult;
37508 }
37509
37510
37511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
37512   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37513   Dali::Actor arg2 ;
37514   Dali::Actor *argp2 ;
37515
37516   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37517   argp2 = (Dali::Actor *)jarg2;
37518   if (!argp2) {
37519     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
37520     return ;
37521   }
37522   arg2 = *argp2;
37523   {
37524     try {
37525       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
37526     } CALL_CATCH_EXCEPTION();
37527   }
37528
37529 }
37530
37531
37532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
37533   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37534   Dali::Actor arg2 ;
37535   Dali::Actor *argp2 ;
37536
37537   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37538   argp2 = (Dali::Actor *)jarg2;
37539   if (!argp2) {
37540     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
37541     return ;
37542   }
37543   arg2 = *argp2;
37544   {
37545     try {
37546       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
37547     } CALL_CATCH_EXCEPTION();
37548   }
37549
37550 }
37551
37552
37553 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
37554   unsigned int jresult ;
37555   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37556   bool result;
37557
37558   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37559   {
37560     try {
37561       result = (bool)(arg1)->OnKeyboardEnter();
37562     } CALL_CATCH_EXCEPTION(0);
37563   }
37564
37565   jresult = result;
37566   return jresult;
37567 }
37568
37569
37570 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
37571   unsigned int jresult ;
37572   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37573   bool result;
37574
37575   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37576   {
37577     try {
37578       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
37579     } CALL_CATCH_EXCEPTION(0);
37580   }
37581
37582   jresult = result;
37583   return jresult;
37584 }
37585
37586
37587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
37588   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37589   Dali::PinchGesture *arg2 = 0 ;
37590
37591   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37592   arg2 = (Dali::PinchGesture *)jarg2;
37593   if (!arg2) {
37594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
37595     return ;
37596   }
37597   {
37598     try {
37599       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
37600     } CALL_CATCH_EXCEPTION();
37601   }
37602
37603 }
37604
37605
37606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
37607   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37608   Dali::PinchGesture *arg2 = 0 ;
37609
37610   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37611   arg2 = (Dali::PinchGesture *)jarg2;
37612   if (!arg2) {
37613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
37614     return ;
37615   }
37616   {
37617     try {
37618       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
37619     } CALL_CATCH_EXCEPTION();
37620   }
37621
37622 }
37623
37624
37625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
37626   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37627   Dali::PanGesture *arg2 = 0 ;
37628
37629   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37630   arg2 = (Dali::PanGesture *)jarg2;
37631   if (!arg2) {
37632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
37633     return ;
37634   }
37635   {
37636     try {
37637       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
37638     } CALL_CATCH_EXCEPTION();
37639   }
37640
37641 }
37642
37643
37644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
37645   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37646   Dali::PanGesture *arg2 = 0 ;
37647
37648   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37649   arg2 = (Dali::PanGesture *)jarg2;
37650   if (!arg2) {
37651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
37652     return ;
37653   }
37654   {
37655     try {
37656       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
37657     } CALL_CATCH_EXCEPTION();
37658   }
37659
37660 }
37661
37662
37663 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
37664   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37665   Dali::TapGesture *arg2 = 0 ;
37666
37667   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37668   arg2 = (Dali::TapGesture *)jarg2;
37669   if (!arg2) {
37670     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
37671     return ;
37672   }
37673   {
37674     try {
37675       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
37676     } CALL_CATCH_EXCEPTION();
37677   }
37678
37679 }
37680
37681
37682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
37683   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37684   Dali::TapGesture *arg2 = 0 ;
37685
37686   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37687   arg2 = (Dali::TapGesture *)jarg2;
37688   if (!arg2) {
37689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
37690     return ;
37691   }
37692   {
37693     try {
37694       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
37695     } CALL_CATCH_EXCEPTION();
37696   }
37697
37698 }
37699
37700
37701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
37702   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37703   Dali::LongPressGesture *arg2 = 0 ;
37704
37705   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37706   arg2 = (Dali::LongPressGesture *)jarg2;
37707   if (!arg2) {
37708     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
37709     return ;
37710   }
37711   {
37712     try {
37713       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
37714     } CALL_CATCH_EXCEPTION();
37715   }
37716
37717 }
37718
37719
37720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
37721   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37722   Dali::LongPressGesture *arg2 = 0 ;
37723
37724   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37725   arg2 = (Dali::LongPressGesture *)jarg2;
37726   if (!arg2) {
37727     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
37728     return ;
37729   }
37730   {
37731     try {
37732       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
37733     } CALL_CATCH_EXCEPTION();
37734   }
37735
37736 }
37737
37738
37739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
37740   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37741   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
37742   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
37743
37744   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37745   arg2 = (Dali::SlotObserver *)jarg2;
37746   arg3 = (Dali::CallbackBase *)jarg3;
37747   {
37748     try {
37749       (arg1)->SignalConnected(arg2,arg3);
37750     } CALL_CATCH_EXCEPTION();
37751   }
37752
37753 }
37754
37755
37756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
37757   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37758   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
37759   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
37760
37761   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37762   arg2 = (Dali::SlotObserver *)jarg2;
37763   arg3 = (Dali::CallbackBase *)jarg3;
37764   {
37765     try {
37766       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
37767     } CALL_CATCH_EXCEPTION();
37768   }
37769
37770 }
37771
37772
37773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
37774   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37775   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
37776   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
37777
37778   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37779   arg2 = (Dali::SlotObserver *)jarg2;
37780   arg3 = (Dali::CallbackBase *)jarg3;
37781   {
37782     try {
37783       (arg1)->SignalDisconnected(arg2,arg3);
37784     } CALL_CATCH_EXCEPTION();
37785   }
37786
37787 }
37788
37789
37790 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
37791   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37792   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
37793   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
37794
37795   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37796   arg2 = (Dali::SlotObserver *)jarg2;
37797   arg3 = (Dali::CallbackBase *)jarg3;
37798   {
37799     try {
37800       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
37801     } CALL_CATCH_EXCEPTION();
37802   }
37803
37804 }
37805
37806 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) {
37807   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
37808   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
37809   if (director) {
37810     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);
37811   }
37812 }
37813
37814
37815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
37816   void * jresult ;
37817   Dali::Toolkit::Control *arg1 = 0 ;
37818   Dali::Toolkit::Internal::Control *result = 0 ;
37819
37820   arg1 = (Dali::Toolkit::Control *)jarg1;
37821   if (!arg1) {
37822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
37823     return 0;
37824   }
37825   {
37826     try {
37827       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
37828     } CALL_CATCH_EXCEPTION(0);
37829   }
37830
37831   jresult = (void *)result;
37832   return jresult;
37833 }
37834
37835
37836 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
37837   int jresult ;
37838   int result;
37839
37840   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
37841   jresult = (int)result;
37842   return jresult;
37843 }
37844
37845 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
37846   int jresult ;
37847   int result;
37848
37849   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
37850   jresult = (int)result;
37851   return jresult;
37852 }
37853
37854
37855 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
37856   int jresult ;
37857   int result;
37858
37859   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
37860   jresult = (int)result;
37861   return jresult;
37862 }
37863
37864 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_MARGIN_get() {
37865   int jresult ;
37866   int result;
37867
37868   result = (int)Dali::Toolkit::Control::Property::MARGIN;
37869   jresult = (int)result;
37870   return jresult;
37871 }
37872
37873
37874 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_PADDING_get() {
37875   int jresult ;
37876   int result;
37877
37878   result = (int)Dali::Toolkit::Control::Property::PADDING;
37879   jresult = (int)result;
37880   return jresult;
37881 }
37882
37883 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_SHADOW_get() {
37884   int jresult ;
37885   int result;
37886
37887   result = (int)Dali::Toolkit::DevelControl::Property::SHADOW;
37888   jresult = (int)result;
37889   return jresult;
37890 }
37891
37892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
37893   void * jresult ;
37894   Dali::Toolkit::Control::Property *result = 0 ;
37895
37896   {
37897     try {
37898       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
37899     } CALL_CATCH_EXCEPTION(0);
37900   }
37901
37902   jresult = (void *)result;
37903   return jresult;
37904 }
37905
37906
37907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
37908   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
37909
37910   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
37911   {
37912     try {
37913       delete arg1;
37914     } CALL_CATCH_EXCEPTION();
37915   }
37916
37917 }
37918
37919
37920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
37921   void * jresult ;
37922   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
37923
37924   {
37925     try {
37926       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
37927     } CALL_CATCH_EXCEPTION(0);
37928   }
37929
37930   jresult = (void *)result;
37931   return jresult;
37932 }
37933
37934
37935 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
37936   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
37937
37938   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
37939   {
37940     try {
37941       delete arg1;
37942     } CALL_CATCH_EXCEPTION();
37943   }
37944
37945 }
37946
37947
37948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
37949   void * jresult ;
37950   Dali::Toolkit::Control result;
37951
37952   {
37953     try {
37954       result = Dali::Toolkit::Control::New();
37955     } CALL_CATCH_EXCEPTION(0);
37956   }
37957
37958   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
37959   return jresult;
37960 }
37961
37962
37963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
37964   void * jresult ;
37965   Dali::Toolkit::Control *result = 0 ;
37966
37967   {
37968     try {
37969       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
37970     } CALL_CATCH_EXCEPTION(0);
37971   }
37972
37973   jresult = (void *)result;
37974   return jresult;
37975 }
37976
37977
37978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
37979   void * jresult ;
37980   Dali::Toolkit::Control *arg1 = 0 ;
37981   Dali::Toolkit::Control *result = 0 ;
37982
37983   arg1 = (Dali::Toolkit::Control *)jarg1;
37984   if (!arg1) {
37985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
37986     return 0;
37987   }
37988   {
37989     try {
37990       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
37991     } CALL_CATCH_EXCEPTION(0);
37992   }
37993
37994   jresult = (void *)result;
37995   return jresult;
37996 }
37997
37998
37999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
38000   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
38001
38002   arg1 = (Dali::Toolkit::Control *)jarg1;
38003   {
38004     try {
38005       delete arg1;
38006     } CALL_CATCH_EXCEPTION();
38007   }
38008
38009 }
38010
38011
38012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
38013   void * jresult ;
38014   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
38015   Dali::Toolkit::Control *arg2 = 0 ;
38016   Dali::Toolkit::Control *result = 0 ;
38017
38018   arg1 = (Dali::Toolkit::Control *)jarg1;
38019   arg2 = (Dali::Toolkit::Control *)jarg2;
38020   if (!arg2) {
38021     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
38022     return 0;
38023   }
38024   {
38025     try {
38026       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
38027     } CALL_CATCH_EXCEPTION(0);
38028   }
38029
38030   jresult = (void *)result;
38031   return jresult;
38032 }
38033
38034
38035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
38036   void * jresult ;
38037   Dali::BaseHandle arg1 ;
38038   Dali::BaseHandle *argp1 ;
38039   Dali::Toolkit::Control result;
38040
38041   argp1 = (Dali::BaseHandle *)jarg1;
38042   if (!argp1) {
38043     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
38044     return 0;
38045   }
38046   arg1 = *argp1;
38047   {
38048     try {
38049       result = Dali::Toolkit::Control::DownCast(arg1);
38050     } CALL_CATCH_EXCEPTION(0);
38051   }
38052
38053   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
38054   return jresult;
38055 }
38056
38057
38058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
38059   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
38060
38061   arg1 = (Dali::Toolkit::Control *)jarg1;
38062   {
38063     try {
38064       (arg1)->SetKeyInputFocus();
38065     } CALL_CATCH_EXCEPTION();
38066   }
38067
38068 }
38069
38070
38071 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
38072   unsigned int jresult ;
38073   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
38074   bool result;
38075
38076   arg1 = (Dali::Toolkit::Control *)jarg1;
38077   {
38078     try {
38079       result = (bool)(arg1)->HasKeyInputFocus();
38080     } CALL_CATCH_EXCEPTION(0);
38081   }
38082
38083   jresult = result;
38084   return jresult;
38085 }
38086
38087
38088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
38089   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
38090
38091   arg1 = (Dali::Toolkit::Control *)jarg1;
38092   {
38093     try {
38094       (arg1)->ClearKeyInputFocus();
38095     } CALL_CATCH_EXCEPTION();
38096   }
38097
38098 }
38099
38100
38101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
38102   void * jresult ;
38103   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
38104   Dali::PinchGestureDetector result;
38105
38106   arg1 = (Dali::Toolkit::Control *)jarg1;
38107   {
38108     try {
38109       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
38110     } CALL_CATCH_EXCEPTION(0);
38111   }
38112
38113   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
38114   return jresult;
38115 }
38116
38117
38118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
38119   void * jresult ;
38120   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
38121   Dali::PanGestureDetector result;
38122
38123   arg1 = (Dali::Toolkit::Control *)jarg1;
38124   {
38125     try {
38126       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
38127     } CALL_CATCH_EXCEPTION(0);
38128   }
38129
38130   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
38131   return jresult;
38132 }
38133
38134
38135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
38136   void * jresult ;
38137   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
38138   Dali::TapGestureDetector result;
38139
38140   arg1 = (Dali::Toolkit::Control *)jarg1;
38141   {
38142     try {
38143       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
38144     } CALL_CATCH_EXCEPTION(0);
38145   }
38146
38147   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
38148   return jresult;
38149 }
38150
38151
38152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
38153   void * jresult ;
38154   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
38155   Dali::LongPressGestureDetector result;
38156
38157   arg1 = (Dali::Toolkit::Control *)jarg1;
38158   {
38159     try {
38160       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
38161     } CALL_CATCH_EXCEPTION(0);
38162   }
38163
38164   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
38165   return jresult;
38166 }
38167
38168
38169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
38170   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
38171   std::string *arg2 = 0 ;
38172
38173   arg1 = (Dali::Toolkit::Control *)jarg1;
38174   if (!jarg2) {
38175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
38176     return ;
38177   }
38178   std::string arg2_str(jarg2);
38179   arg2 = &arg2_str;
38180   {
38181     try {
38182       (arg1)->SetStyleName((std::string const &)*arg2);
38183     } CALL_CATCH_EXCEPTION();
38184   }
38185
38186
38187   //argout typemap for const std::string&
38188
38189 }
38190
38191
38192 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
38193   char * jresult ;
38194   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
38195   std::string *result = 0 ;
38196
38197   arg1 = (Dali::Toolkit::Control *)jarg1;
38198   {
38199     try {
38200       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
38201     } CALL_CATCH_EXCEPTION(0);
38202   }
38203
38204   jresult = SWIG_csharp_string_callback(result->c_str());
38205   return jresult;
38206 }
38207
38208
38209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
38210   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
38211   Dali::Vector4 *arg2 = 0 ;
38212
38213   arg1 = (Dali::Toolkit::Control *)jarg1;
38214   arg2 = (Dali::Vector4 *)jarg2;
38215   if (!arg2) {
38216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
38217     return ;
38218   }
38219   {
38220     try {
38221       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
38222     } CALL_CATCH_EXCEPTION();
38223   }
38224
38225 }
38226
38227 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
38228   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
38229
38230   arg1 = (Dali::Toolkit::Control *)jarg1;
38231   {
38232     try {
38233       (arg1)->ClearBackground();
38234     } CALL_CATCH_EXCEPTION();
38235   }
38236
38237 }
38238
38239
38240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyEventSignal(void * jarg1) {
38241   void * jresult ;
38242   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
38243   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
38244
38245   arg1 = (Dali::Toolkit::Control *)jarg1;
38246   {
38247     try {
38248       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
38249     } CALL_CATCH_EXCEPTION(0);
38250   }
38251
38252   jresult = (void *)result;
38253   return jresult;
38254 }
38255
38256
38257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
38258   void * jresult ;
38259   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
38260   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
38261
38262   arg1 = (Dali::Toolkit::Control *)jarg1;
38263   {
38264     try {
38265       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
38266     } CALL_CATCH_EXCEPTION(0);
38267   }
38268
38269   jresult = (void *)result;
38270   return jresult;
38271 }
38272
38273
38274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
38275   void * jresult ;
38276   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
38277   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
38278
38279   arg1 = (Dali::Toolkit::Control *)jarg1;
38280   {
38281     try {
38282       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
38283     } CALL_CATCH_EXCEPTION(0);
38284   }
38285
38286   jresult = (void *)result;
38287   return jresult;
38288 }
38289
38290
38291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
38292   void * jresult ;
38293   Dali::Toolkit::Internal::Control *arg1 = 0 ;
38294   Dali::Toolkit::Control *result = 0 ;
38295
38296   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38297   if (!arg1) {
38298     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
38299     return 0;
38300   }
38301   {
38302     try {
38303       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
38304     } CALL_CATCH_EXCEPTION(0);
38305   }
38306
38307   jresult = (void *)result;
38308   return jresult;
38309 }
38310
38311 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_GetVisualResourceStatus(void * jarg1, int jarg2)
38312 {
38313   int jresult;
38314   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
38315   arg1 = (Dali::Toolkit::Control *)jarg1;
38316
38317   if (!arg1) {
38318     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
38319     return 0;
38320   }
38321
38322   Dali::Property::Index arg2 = 0 ;
38323   arg2 = (Dali::Property::Index)jarg2;
38324
38325   Toolkit::Visual::ResourceStatus result;
38326   {
38327     try {
38328       result = arg1->GetVisualResourceStatus(arg2);
38329     } CALL_CATCH_EXCEPTION(0);
38330   }
38331
38332   jresult = (int)result;
38333   return jresult;
38334 }
38335
38336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_CreateTransition(void * jarg1, void * jarg2)
38337 {
38338   void * jresult;
38339   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
38340   arg1 = (Dali::Toolkit::Control *)jarg1;
38341
38342   Dali::Toolkit::Internal::Control& controlImpl = Dali::Toolkit::Internal::GetImplementation( *arg1 );
38343
38344   Dali::Toolkit::TransitionData *arg2 = 0 ;
38345   Dali::Animation result;
38346
38347   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
38348   if (!arg2) {
38349     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
38350     return 0;
38351   }
38352   {
38353     try {
38354       result = DevelControl::CreateTransition( controlImpl, (Dali::Toolkit::TransitionData const &)*arg2);
38355     } CALL_CATCH_EXCEPTION(0);
38356   }
38357
38358   jresult = new Dali::Animation((const Dali::Animation &)result);
38359   return jresult;
38360 }
38361
38362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_DoAction(void * jarg1, int jarg2, int jarg3, void * jarg4 )
38363 {
38364   Dali::Toolkit::Control arg1;
38365   Dali::Toolkit::Control *argp1  = (Dali::Toolkit::Control *)jarg1;
38366
38367   if (!argp1) {
38368     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
38369   }
38370   arg1 = *argp1;
38371
38372   Dali::Property::Index arg2 = 0 ;
38373   arg2 = (Dali::Property::Index)jarg2;
38374
38375   Dali::Property::Index arg3 = 0 ;
38376   arg3 = (Dali::Property::Index)jarg3;
38377
38378   Dali::Property::Value *arg4 = (Dali::Property::Value *)jarg4;
38379
38380   {
38381     try {
38382       DevelControl::DoAction(arg1, arg2, arg3, *arg4);
38383     } CALL_CATCH_EXCEPTION();
38384   }
38385 }
38386
38387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceReadySignal(void * jarg1) {
38388   void * jresult ;
38389   Dali::Toolkit::Control *arg1 = 0 ;
38390   Dali::Toolkit::Control::ResourceReadySignalType *result = 0 ;
38391
38392   arg1 = (Dali::Toolkit::Control *)jarg1;
38393   if (!arg1) {
38394     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
38395     return 0;
38396   }
38397   {
38398     try {
38399       result = (Dali::Toolkit::Control::ResourceReadySignalType *) &arg1->ResourceReadySignal();
38400     } CALL_CATCH_EXCEPTION(0);
38401   }
38402
38403   jresult = (void *)result;
38404   return jresult;
38405 }
38406
38407
38408 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsResourceReady(void * jarg1) {
38409   unsigned int jresult ;
38410   Dali::Toolkit::Control *arg1 = 0 ;
38411   bool result;
38412
38413   arg1 = (Dali::Toolkit::Control *)jarg1;
38414   if (!arg1) {
38415     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
38416     return 0;
38417   }
38418   {
38419     try {
38420       result = (bool)arg1->IsResourceReady();
38421     } CALL_CATCH_EXCEPTION(0);
38422   }
38423
38424   jresult = result;
38425   return jresult;
38426 }
38427
38428
38429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
38430   void * jresult ;
38431   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
38432
38433   {
38434     try {
38435       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
38436     } CALL_CATCH_EXCEPTION(0);
38437   }
38438
38439   jresult = (void *)result;
38440   return jresult;
38441 }
38442
38443
38444 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
38445   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
38446
38447   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
38448   {
38449     try {
38450       delete arg1;
38451     } CALL_CATCH_EXCEPTION();
38452   }
38453
38454 }
38455
38456
38457 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
38458   void * jresult ;
38459   Dali::Toolkit::KeyInputFocusManager result;
38460
38461   {
38462     try {
38463       result = Dali::Toolkit::KeyInputFocusManager::Get();
38464     } CALL_CATCH_EXCEPTION(0);
38465   }
38466
38467   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
38468   return jresult;
38469 }
38470
38471
38472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
38473   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
38474   Dali::Toolkit::Control arg2 ;
38475   Dali::Toolkit::Control *argp2 ;
38476
38477   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
38478   argp2 = (Dali::Toolkit::Control *)jarg2;
38479   if (!argp2) {
38480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
38481     return ;
38482   }
38483   arg2 = *argp2;
38484   {
38485     try {
38486       (arg1)->SetFocus(arg2);
38487     } CALL_CATCH_EXCEPTION();
38488   }
38489
38490 }
38491
38492
38493 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
38494   void * jresult ;
38495   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
38496   Dali::Toolkit::Control result;
38497
38498   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
38499   {
38500     try {
38501       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
38502     } CALL_CATCH_EXCEPTION(0);
38503   }
38504
38505   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
38506   return jresult;
38507 }
38508
38509
38510 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
38511   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
38512   Dali::Toolkit::Control arg2 ;
38513   Dali::Toolkit::Control *argp2 ;
38514
38515   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
38516   argp2 = (Dali::Toolkit::Control *)jarg2;
38517   if (!argp2) {
38518     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
38519     return ;
38520   }
38521   arg2 = *argp2;
38522   {
38523     try {
38524       (arg1)->RemoveFocus(arg2);
38525     } CALL_CATCH_EXCEPTION();
38526   }
38527
38528 }
38529
38530
38531 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
38532   void * jresult ;
38533   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
38534   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
38535
38536   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
38537   {
38538     try {
38539       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
38540     } CALL_CATCH_EXCEPTION(0);
38541   }
38542
38543   jresult = (void *)result;
38544   return jresult;
38545 }
38546
38547
38548 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
38549   void * jresult ;
38550   Dali::Toolkit::Alignment::Padding *result = 0 ;
38551
38552   {
38553     try {
38554       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
38555     } CALL_CATCH_EXCEPTION(0);
38556   }
38557
38558   jresult = (void *)result;
38559   return jresult;
38560 }
38561
38562
38563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
38564   void * jresult ;
38565   float arg1 ;
38566   float arg2 ;
38567   float arg3 ;
38568   float arg4 ;
38569   Dali::Toolkit::Alignment::Padding *result = 0 ;
38570
38571   arg1 = (float)jarg1;
38572   arg2 = (float)jarg2;
38573   arg3 = (float)jarg3;
38574   arg4 = (float)jarg4;
38575   {
38576     try {
38577       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
38578     } CALL_CATCH_EXCEPTION(0);
38579   }
38580
38581   jresult = (void *)result;
38582   return jresult;
38583 }
38584
38585
38586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
38587   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
38588   float arg2 ;
38589
38590   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
38591   arg2 = (float)jarg2;
38592   if (arg1) (arg1)->left = arg2;
38593 }
38594
38595
38596 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
38597   float jresult ;
38598   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
38599   float result;
38600
38601   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
38602   result = (float) ((arg1)->left);
38603   jresult = result;
38604   return jresult;
38605 }
38606
38607
38608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
38609   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
38610   float arg2 ;
38611
38612   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
38613   arg2 = (float)jarg2;
38614   if (arg1) (arg1)->right = arg2;
38615 }
38616
38617
38618 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
38619   float jresult ;
38620   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
38621   float result;
38622
38623   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
38624   result = (float) ((arg1)->right);
38625   jresult = result;
38626   return jresult;
38627 }
38628
38629
38630 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
38631   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
38632   float arg2 ;
38633
38634   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
38635   arg2 = (float)jarg2;
38636   if (arg1) (arg1)->top = arg2;
38637 }
38638
38639
38640 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
38641   float jresult ;
38642   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
38643   float result;
38644
38645   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
38646   result = (float) ((arg1)->top);
38647   jresult = result;
38648   return jresult;
38649 }
38650
38651
38652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
38653   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
38654   float arg2 ;
38655
38656   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
38657   arg2 = (float)jarg2;
38658   if (arg1) (arg1)->bottom = arg2;
38659 }
38660
38661
38662 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
38663   float jresult ;
38664   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
38665   float result;
38666
38667   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
38668   result = (float) ((arg1)->bottom);
38669   jresult = result;
38670   return jresult;
38671 }
38672
38673
38674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
38675   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
38676
38677   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
38678   {
38679     try {
38680       delete arg1;
38681     } CALL_CATCH_EXCEPTION();
38682   }
38683
38684 }
38685
38686
38687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
38688   void * jresult ;
38689   Dali::Toolkit::Alignment *result = 0 ;
38690
38691   {
38692     try {
38693       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
38694     } CALL_CATCH_EXCEPTION(0);
38695   }
38696
38697   jresult = (void *)result;
38698   return jresult;
38699 }
38700
38701
38702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
38703   void * jresult ;
38704   Dali::Toolkit::Alignment::Type arg1 ;
38705   Dali::Toolkit::Alignment::Type arg2 ;
38706   Dali::Toolkit::Alignment result;
38707
38708   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
38709   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
38710   {
38711     try {
38712       result = Dali::Toolkit::Alignment::New(arg1,arg2);
38713     } CALL_CATCH_EXCEPTION(0);
38714   }
38715
38716   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
38717   return jresult;
38718 }
38719
38720
38721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
38722   void * jresult ;
38723   Dali::Toolkit::Alignment::Type arg1 ;
38724   Dali::Toolkit::Alignment result;
38725
38726   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
38727   {
38728     try {
38729       result = Dali::Toolkit::Alignment::New(arg1);
38730     } CALL_CATCH_EXCEPTION(0);
38731   }
38732
38733   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
38734   return jresult;
38735 }
38736
38737
38738 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
38739   void * jresult ;
38740   Dali::Toolkit::Alignment result;
38741
38742   {
38743     try {
38744       result = Dali::Toolkit::Alignment::New();
38745     } CALL_CATCH_EXCEPTION(0);
38746   }
38747
38748   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
38749   return jresult;
38750 }
38751
38752
38753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
38754   void * jresult ;
38755   Dali::Toolkit::Alignment *arg1 = 0 ;
38756   Dali::Toolkit::Alignment *result = 0 ;
38757
38758   arg1 = (Dali::Toolkit::Alignment *)jarg1;
38759   if (!arg1) {
38760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
38761     return 0;
38762   }
38763   {
38764     try {
38765       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
38766     } CALL_CATCH_EXCEPTION(0);
38767   }
38768
38769   jresult = (void *)result;
38770   return jresult;
38771 }
38772
38773
38774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
38775   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
38776
38777   arg1 = (Dali::Toolkit::Alignment *)jarg1;
38778   {
38779     try {
38780       delete arg1;
38781     } CALL_CATCH_EXCEPTION();
38782   }
38783
38784 }
38785
38786
38787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
38788   void * jresult ;
38789   Dali::BaseHandle arg1 ;
38790   Dali::BaseHandle *argp1 ;
38791   Dali::Toolkit::Alignment result;
38792
38793   argp1 = (Dali::BaseHandle *)jarg1;
38794   if (!argp1) {
38795     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
38796     return 0;
38797   }
38798   arg1 = *argp1;
38799   {
38800     try {
38801       result = Dali::Toolkit::Alignment::DownCast(arg1);
38802     } CALL_CATCH_EXCEPTION(0);
38803   }
38804
38805   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
38806   return jresult;
38807 }
38808
38809
38810 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
38811   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
38812   Dali::Toolkit::Alignment::Type arg2 ;
38813
38814   arg1 = (Dali::Toolkit::Alignment *)jarg1;
38815   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
38816   {
38817     try {
38818       (arg1)->SetAlignmentType(arg2);
38819     } CALL_CATCH_EXCEPTION();
38820   }
38821
38822 }
38823
38824
38825 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
38826   int jresult ;
38827   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
38828   Dali::Toolkit::Alignment::Type result;
38829
38830   arg1 = (Dali::Toolkit::Alignment *)jarg1;
38831   {
38832     try {
38833       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
38834     } CALL_CATCH_EXCEPTION(0);
38835   }
38836
38837   jresult = (int)result;
38838   return jresult;
38839 }
38840
38841
38842 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
38843   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
38844   Dali::Toolkit::Alignment::Scaling arg2 ;
38845
38846   arg1 = (Dali::Toolkit::Alignment *)jarg1;
38847   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
38848   {
38849     try {
38850       (arg1)->SetScaling(arg2);
38851     } CALL_CATCH_EXCEPTION();
38852   }
38853
38854 }
38855
38856
38857 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
38858   int jresult ;
38859   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
38860   Dali::Toolkit::Alignment::Scaling result;
38861
38862   arg1 = (Dali::Toolkit::Alignment *)jarg1;
38863   {
38864     try {
38865       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
38866     } CALL_CATCH_EXCEPTION(0);
38867   }
38868
38869   jresult = (int)result;
38870   return jresult;
38871 }
38872
38873
38874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
38875   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
38876   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
38877
38878   arg1 = (Dali::Toolkit::Alignment *)jarg1;
38879   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
38880   if (!arg2) {
38881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
38882     return ;
38883   }
38884   {
38885     try {
38886       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
38887     } CALL_CATCH_EXCEPTION();
38888   }
38889
38890 }
38891
38892
38893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
38894   void * jresult ;
38895   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
38896   Dali::Toolkit::Alignment::Padding *result = 0 ;
38897
38898   arg1 = (Dali::Toolkit::Alignment *)jarg1;
38899   {
38900     try {
38901       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
38902     } CALL_CATCH_EXCEPTION(0);
38903   }
38904
38905   jresult = (void *)result;
38906   return jresult;
38907 }
38908
38909
38910 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
38911   void * jresult ;
38912   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
38913   Dali::Toolkit::Alignment *arg2 = 0 ;
38914   Dali::Toolkit::Alignment *result = 0 ;
38915
38916   arg1 = (Dali::Toolkit::Alignment *)jarg1;
38917   arg2 = (Dali::Toolkit::Alignment *)jarg2;
38918   if (!arg2) {
38919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
38920     return 0;
38921   }
38922   {
38923     try {
38924       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
38925     } CALL_CATCH_EXCEPTION(0);
38926   }
38927
38928   jresult = (void *)result;
38929   return jresult;
38930 }
38931
38932
38933 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
38934   int jresult ;
38935   int result;
38936
38937   result = (int)Dali::Toolkit::Button::Property::DISABLED;
38938   jresult = (int)result;
38939   return jresult;
38940 }
38941
38942
38943 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
38944   int jresult ;
38945   int result;
38946
38947   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
38948   jresult = (int)result;
38949   return jresult;
38950 }
38951
38952
38953 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
38954   int jresult ;
38955   int result;
38956
38957   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
38958   jresult = (int)result;
38959   return jresult;
38960 }
38961
38962
38963 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
38964   int jresult ;
38965   int result;
38966
38967   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
38968   jresult = (int)result;
38969   return jresult;
38970 }
38971
38972
38973 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
38974   int jresult ;
38975   int result;
38976
38977   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
38978   jresult = (int)result;
38979   return jresult;
38980 }
38981
38982
38983 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
38984   int jresult ;
38985   int result;
38986
38987   result = (int)Dali::Toolkit::Button::Property::SELECTED;
38988   jresult = (int)result;
38989   return jresult;
38990 }
38991
38992 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
38993   int jresult ;
38994   int result;
38995
38996   result = (int)Dali::Toolkit::Button::Property::LABEL;
38997   jresult = (int)result;
38998   return jresult;
38999 }
39000
39001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
39002   void * jresult ;
39003   Dali::Toolkit::Button::Property *result = 0 ;
39004
39005   {
39006     try {
39007       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
39008     } CALL_CATCH_EXCEPTION(0);
39009   }
39010
39011   jresult = (void *)result;
39012   return jresult;
39013 }
39014
39015
39016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
39017   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
39018
39019   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
39020   {
39021     try {
39022       delete arg1;
39023     } CALL_CATCH_EXCEPTION();
39024   }
39025
39026 }
39027
39028
39029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
39030   void * jresult ;
39031   Dali::Toolkit::Button *result = 0 ;
39032
39033   {
39034     try {
39035       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
39036     } CALL_CATCH_EXCEPTION(0);
39037   }
39038
39039   jresult = (void *)result;
39040   return jresult;
39041 }
39042
39043
39044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
39045   void * jresult ;
39046   Dali::Toolkit::Button *arg1 = 0 ;
39047   Dali::Toolkit::Button *result = 0 ;
39048
39049   arg1 = (Dali::Toolkit::Button *)jarg1;
39050   if (!arg1) {
39051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
39052     return 0;
39053   }
39054   {
39055     try {
39056       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
39057     } CALL_CATCH_EXCEPTION(0);
39058   }
39059
39060   jresult = (void *)result;
39061   return jresult;
39062 }
39063
39064
39065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
39066   void * jresult ;
39067   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
39068   Dali::Toolkit::Button *arg2 = 0 ;
39069   Dali::Toolkit::Button *result = 0 ;
39070
39071   arg1 = (Dali::Toolkit::Button *)jarg1;
39072   arg2 = (Dali::Toolkit::Button *)jarg2;
39073   if (!arg2) {
39074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
39075     return 0;
39076   }
39077   {
39078     try {
39079       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
39080     } CALL_CATCH_EXCEPTION(0);
39081   }
39082
39083   jresult = (void *)result;
39084   return jresult;
39085 }
39086
39087
39088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
39089   void * jresult ;
39090   Dali::BaseHandle arg1 ;
39091   Dali::BaseHandle *argp1 ;
39092   Dali::Toolkit::Button result;
39093
39094   argp1 = (Dali::BaseHandle *)jarg1;
39095   if (!argp1) {
39096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
39097     return 0;
39098   }
39099   arg1 = *argp1;
39100   {
39101     try {
39102       result = Dali::Toolkit::Button::DownCast(arg1);
39103     } CALL_CATCH_EXCEPTION(0);
39104   }
39105
39106   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
39107   return jresult;
39108 }
39109
39110
39111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
39112   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
39113
39114   arg1 = (Dali::Toolkit::Button *)jarg1;
39115   {
39116     try {
39117       delete arg1;
39118     } CALL_CATCH_EXCEPTION();
39119   }
39120
39121 }
39122
39123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
39124   void * jresult ;
39125   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
39126   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
39127
39128   arg1 = (Dali::Toolkit::Button *)jarg1;
39129   {
39130     try {
39131       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
39132     } CALL_CATCH_EXCEPTION(0);
39133   }
39134
39135   jresult = (void *)result;
39136   return jresult;
39137 }
39138
39139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
39140   void * jresult ;
39141   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
39142   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
39143
39144   arg1 = (Dali::Toolkit::Button *)jarg1;
39145   {
39146     try {
39147       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
39148     } CALL_CATCH_EXCEPTION(0);
39149   }
39150
39151   jresult = (void *)result;
39152   return jresult;
39153 }
39154
39155
39156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
39157   void * jresult ;
39158   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
39159   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
39160
39161   arg1 = (Dali::Toolkit::Button *)jarg1;
39162   {
39163     try {
39164       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
39165     } CALL_CATCH_EXCEPTION(0);
39166   }
39167
39168   jresult = (void *)result;
39169   return jresult;
39170 }
39171
39172
39173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
39174   void * jresult ;
39175   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
39176   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
39177
39178   arg1 = (Dali::Toolkit::Button *)jarg1;
39179   {
39180     try {
39181       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
39182     } CALL_CATCH_EXCEPTION(0);
39183   }
39184
39185   jresult = (void *)result;
39186   return jresult;
39187 }
39188
39189
39190 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
39191   void * jresult ;
39192   Dali::Toolkit::CheckBoxButton *result = 0 ;
39193
39194   {
39195     try {
39196       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
39197     } CALL_CATCH_EXCEPTION(0);
39198   }
39199
39200   jresult = (void *)result;
39201   return jresult;
39202 }
39203
39204
39205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
39206   void * jresult ;
39207   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
39208   Dali::Toolkit::CheckBoxButton *result = 0 ;
39209
39210   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
39211   if (!arg1) {
39212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
39213     return 0;
39214   }
39215   {
39216     try {
39217       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
39218     } CALL_CATCH_EXCEPTION(0);
39219   }
39220
39221   jresult = (void *)result;
39222   return jresult;
39223 }
39224
39225
39226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
39227   void * jresult ;
39228   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
39229   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
39230   Dali::Toolkit::CheckBoxButton *result = 0 ;
39231
39232   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
39233   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
39234   if (!arg2) {
39235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
39236     return 0;
39237   }
39238   {
39239     try {
39240       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
39241     } CALL_CATCH_EXCEPTION(0);
39242   }
39243
39244   jresult = (void *)result;
39245   return jresult;
39246 }
39247
39248
39249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
39250   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
39251
39252   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
39253   {
39254     try {
39255       delete arg1;
39256     } CALL_CATCH_EXCEPTION();
39257   }
39258
39259 }
39260
39261
39262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
39263   void * jresult ;
39264   Dali::Toolkit::CheckBoxButton result;
39265
39266   {
39267     try {
39268       result = Dali::Toolkit::CheckBoxButton::New();
39269     } CALL_CATCH_EXCEPTION(0);
39270   }
39271
39272   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
39273   return jresult;
39274 }
39275
39276
39277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
39278   void * jresult ;
39279   Dali::BaseHandle arg1 ;
39280   Dali::BaseHandle *argp1 ;
39281   Dali::Toolkit::CheckBoxButton result;
39282
39283   argp1 = (Dali::BaseHandle *)jarg1;
39284   if (!argp1) {
39285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
39286     return 0;
39287   }
39288   arg1 = *argp1;
39289   {
39290     try {
39291       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
39292     } CALL_CATCH_EXCEPTION(0);
39293   }
39294
39295   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
39296   return jresult;
39297 }
39298
39299
39300 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
39301   int jresult ;
39302   int result;
39303
39304   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
39305   jresult = (int)result;
39306   return jresult;
39307 }
39308
39309
39310 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
39311   int jresult ;
39312   int result;
39313
39314   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
39315   jresult = (int)result;
39316   return jresult;
39317 }
39318
39319
39320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
39321   void * jresult ;
39322   Dali::Toolkit::PushButton::Property *result = 0 ;
39323
39324   {
39325     try {
39326       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
39327     } CALL_CATCH_EXCEPTION(0);
39328   }
39329
39330   jresult = (void *)result;
39331   return jresult;
39332 }
39333
39334
39335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
39336   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
39337
39338   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
39339   {
39340     try {
39341       delete arg1;
39342     } CALL_CATCH_EXCEPTION();
39343   }
39344
39345 }
39346
39347
39348 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
39349   void * jresult ;
39350   Dali::Toolkit::PushButton *result = 0 ;
39351
39352   {
39353     try {
39354       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
39355     } CALL_CATCH_EXCEPTION(0);
39356   }
39357
39358   jresult = (void *)result;
39359   return jresult;
39360 }
39361
39362
39363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
39364   void * jresult ;
39365   Dali::Toolkit::PushButton *arg1 = 0 ;
39366   Dali::Toolkit::PushButton *result = 0 ;
39367
39368   arg1 = (Dali::Toolkit::PushButton *)jarg1;
39369   if (!arg1) {
39370     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
39371     return 0;
39372   }
39373   {
39374     try {
39375       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
39376     } CALL_CATCH_EXCEPTION(0);
39377   }
39378
39379   jresult = (void *)result;
39380   return jresult;
39381 }
39382
39383
39384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
39385   void * jresult ;
39386   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
39387   Dali::Toolkit::PushButton *arg2 = 0 ;
39388   Dali::Toolkit::PushButton *result = 0 ;
39389
39390   arg1 = (Dali::Toolkit::PushButton *)jarg1;
39391   arg2 = (Dali::Toolkit::PushButton *)jarg2;
39392   if (!arg2) {
39393     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
39394     return 0;
39395   }
39396   {
39397     try {
39398       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
39399     } CALL_CATCH_EXCEPTION(0);
39400   }
39401
39402   jresult = (void *)result;
39403   return jresult;
39404 }
39405
39406
39407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
39408   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
39409
39410   arg1 = (Dali::Toolkit::PushButton *)jarg1;
39411   {
39412     try {
39413       delete arg1;
39414     } CALL_CATCH_EXCEPTION();
39415   }
39416
39417 }
39418
39419
39420 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
39421   void * jresult ;
39422   Dali::Toolkit::PushButton result;
39423
39424   {
39425     try {
39426       result = Dali::Toolkit::PushButton::New();
39427     } CALL_CATCH_EXCEPTION(0);
39428   }
39429
39430   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
39431   return jresult;
39432 }
39433
39434
39435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
39436   void * jresult ;
39437   Dali::BaseHandle arg1 ;
39438   Dali::BaseHandle *argp1 ;
39439   Dali::Toolkit::PushButton result;
39440
39441   argp1 = (Dali::BaseHandle *)jarg1;
39442   if (!argp1) {
39443     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
39444     return 0;
39445   }
39446   arg1 = *argp1;
39447   {
39448     try {
39449       result = Dali::Toolkit::PushButton::DownCast(arg1);
39450     } CALL_CATCH_EXCEPTION(0);
39451   }
39452
39453   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
39454   return jresult;
39455 }
39456
39457 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
39458   void * jresult ;
39459   Dali::Toolkit::RadioButton *result = 0 ;
39460
39461   {
39462     try {
39463       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
39464     } CALL_CATCH_EXCEPTION(0);
39465   }
39466
39467   jresult = (void *)result;
39468   return jresult;
39469 }
39470
39471
39472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
39473   void * jresult ;
39474   Dali::Toolkit::RadioButton *arg1 = 0 ;
39475   Dali::Toolkit::RadioButton *result = 0 ;
39476
39477   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
39478   if (!arg1) {
39479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
39480     return 0;
39481   }
39482   {
39483     try {
39484       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
39485     } CALL_CATCH_EXCEPTION(0);
39486   }
39487
39488   jresult = (void *)result;
39489   return jresult;
39490 }
39491
39492
39493 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
39494   void * jresult ;
39495   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
39496   Dali::Toolkit::RadioButton *arg2 = 0 ;
39497   Dali::Toolkit::RadioButton *result = 0 ;
39498
39499   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
39500   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
39501   if (!arg2) {
39502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
39503     return 0;
39504   }
39505   {
39506     try {
39507       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
39508     } CALL_CATCH_EXCEPTION(0);
39509   }
39510
39511   jresult = (void *)result;
39512   return jresult;
39513 }
39514
39515
39516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
39517   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
39518
39519   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
39520   {
39521     try {
39522       delete arg1;
39523     } CALL_CATCH_EXCEPTION();
39524   }
39525
39526 }
39527
39528
39529 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
39530   void * jresult ;
39531   Dali::Toolkit::RadioButton result;
39532
39533   {
39534     try {
39535       result = Dali::Toolkit::RadioButton::New();
39536     } CALL_CATCH_EXCEPTION(0);
39537   }
39538
39539   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
39540   return jresult;
39541 }
39542
39543
39544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
39545   void * jresult ;
39546   std::string *arg1 = 0 ;
39547   Dali::Toolkit::RadioButton result;
39548
39549   if (!jarg1) {
39550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
39551     return 0;
39552   }
39553   std::string arg1_str(jarg1);
39554   arg1 = &arg1_str;
39555   {
39556     try {
39557       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
39558     } CALL_CATCH_EXCEPTION(0);
39559   }
39560
39561   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
39562
39563   //argout typemap for const std::string&
39564
39565   return jresult;
39566 }
39567
39568
39569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
39570   void * jresult ;
39571   Dali::BaseHandle arg1 ;
39572   Dali::BaseHandle *argp1 ;
39573   Dali::Toolkit::RadioButton result;
39574
39575   argp1 = (Dali::BaseHandle *)jarg1;
39576   if (!argp1) {
39577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
39578     return 0;
39579   }
39580   arg1 = *argp1;
39581   {
39582     try {
39583       result = Dali::Toolkit::RadioButton::DownCast(arg1);
39584     } CALL_CATCH_EXCEPTION(0);
39585   }
39586
39587   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
39588   return jresult;
39589 }
39590
39591
39592 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
39593   int jresult ;
39594   int result;
39595
39596   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
39597   jresult = (int)result;
39598   return jresult;
39599 }
39600
39601
39602 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
39603   int jresult ;
39604   int result;
39605
39606   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
39607   jresult = (int)result;
39608   return jresult;
39609 }
39610
39611
39612 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
39613   int jresult ;
39614   int result;
39615
39616   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
39617   jresult = (int)result;
39618   return jresult;
39619 }
39620
39621
39622 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
39623   int jresult ;
39624   int result;
39625
39626   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
39627   jresult = (int)result;
39628   return jresult;
39629 }
39630
39631
39632 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
39633   int jresult ;
39634   int result;
39635
39636   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
39637   jresult = (int)result;
39638   return jresult;
39639 }
39640
39641
39642 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
39643   int jresult ;
39644   int result;
39645
39646   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
39647   jresult = (int)result;
39648   return jresult;
39649 }
39650
39651
39652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
39653   void * jresult ;
39654   Dali::Toolkit::FlexContainer::Property *result = 0 ;
39655
39656   {
39657     try {
39658       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
39659     } CALL_CATCH_EXCEPTION(0);
39660   }
39661
39662   jresult = (void *)result;
39663   return jresult;
39664 }
39665
39666
39667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
39668   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
39669
39670   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
39671   {
39672     try {
39673       delete arg1;
39674     } CALL_CATCH_EXCEPTION();
39675   }
39676
39677 }
39678
39679
39680 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
39681   int jresult ;
39682   int result;
39683
39684   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
39685   jresult = (int)result;
39686   return jresult;
39687 }
39688
39689
39690 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
39691   int jresult ;
39692   int result;
39693
39694   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
39695   jresult = (int)result;
39696   return jresult;
39697 }
39698
39699
39700 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
39701   int jresult ;
39702   int result;
39703
39704   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
39705   jresult = (int)result;
39706   return jresult;
39707 }
39708
39709
39710 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
39711   void * jresult ;
39712   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
39713
39714   {
39715     try {
39716       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
39717     } CALL_CATCH_EXCEPTION(0);
39718   }
39719
39720   jresult = (void *)result;
39721   return jresult;
39722 }
39723
39724
39725 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
39726   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
39727
39728   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
39729   {
39730     try {
39731       delete arg1;
39732     } CALL_CATCH_EXCEPTION();
39733   }
39734
39735 }
39736
39737
39738 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
39739   void * jresult ;
39740   Dali::Toolkit::FlexContainer *result = 0 ;
39741
39742   {
39743     try {
39744       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
39745     } CALL_CATCH_EXCEPTION(0);
39746   }
39747
39748   jresult = (void *)result;
39749   return jresult;
39750 }
39751
39752
39753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
39754   void * jresult ;
39755   Dali::Toolkit::FlexContainer *arg1 = 0 ;
39756   Dali::Toolkit::FlexContainer *result = 0 ;
39757
39758   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
39759   if (!arg1) {
39760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
39761     return 0;
39762   }
39763   {
39764     try {
39765       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
39766     } CALL_CATCH_EXCEPTION(0);
39767   }
39768
39769   jresult = (void *)result;
39770   return jresult;
39771 }
39772
39773
39774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
39775   void * jresult ;
39776   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
39777   Dali::Toolkit::FlexContainer *arg2 = 0 ;
39778   Dali::Toolkit::FlexContainer *result = 0 ;
39779
39780   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
39781   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
39782   if (!arg2) {
39783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
39784     return 0;
39785   }
39786   {
39787     try {
39788       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
39789     } CALL_CATCH_EXCEPTION(0);
39790   }
39791
39792   jresult = (void *)result;
39793   return jresult;
39794 }
39795
39796
39797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
39798   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
39799
39800   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
39801   {
39802     try {
39803       delete arg1;
39804     } CALL_CATCH_EXCEPTION();
39805   }
39806
39807 }
39808
39809
39810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
39811   void * jresult ;
39812   Dali::Toolkit::FlexContainer result;
39813
39814   {
39815     try {
39816       result = Dali::Toolkit::FlexContainer::New();
39817     } CALL_CATCH_EXCEPTION(0);
39818   }
39819
39820   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
39821   return jresult;
39822 }
39823
39824
39825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
39826   void * jresult ;
39827   Dali::BaseHandle arg1 ;
39828   Dali::BaseHandle *argp1 ;
39829   Dali::Toolkit::FlexContainer result;
39830
39831   argp1 = (Dali::BaseHandle *)jarg1;
39832   if (!argp1) {
39833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
39834     return 0;
39835   }
39836   arg1 = *argp1;
39837   {
39838     try {
39839       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
39840     } CALL_CATCH_EXCEPTION(0);
39841   }
39842
39843   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
39844   return jresult;
39845 }
39846
39847 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
39848   int jresult ;
39849   int result;
39850
39851   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
39852   jresult = (int)result;
39853   return jresult;
39854 }
39855
39856
39857 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
39858   int jresult ;
39859   int result;
39860
39861   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
39862   jresult = (int)result;
39863   return jresult;
39864 }
39865
39866
39867 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
39868   int jresult ;
39869   int result;
39870
39871   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
39872   jresult = (int)result;
39873   return jresult;
39874 }
39875
39876
39877 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
39878   void * jresult ;
39879   Dali::Toolkit::ImageView::Property *result = 0 ;
39880
39881   {
39882     try {
39883       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
39884     } CALL_CATCH_EXCEPTION(0);
39885   }
39886
39887   jresult = (void *)result;
39888   return jresult;
39889 }
39890
39891
39892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
39893   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
39894
39895   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
39896   {
39897     try {
39898       delete arg1;
39899     } CALL_CATCH_EXCEPTION();
39900   }
39901
39902 }
39903
39904
39905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
39906   void * jresult ;
39907   Dali::Toolkit::ImageView *result = 0 ;
39908
39909   {
39910     try {
39911       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
39912     } CALL_CATCH_EXCEPTION(0);
39913   }
39914
39915   jresult = (void *)result;
39916   return jresult;
39917 }
39918
39919
39920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
39921   void * jresult ;
39922   Dali::Toolkit::ImageView result;
39923
39924   {
39925     try {
39926       result = Dali::Toolkit::ImageView::New();
39927     } CALL_CATCH_EXCEPTION(0);
39928   }
39929
39930   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
39931   return jresult;
39932 }
39933
39934
39935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
39936   void * jresult ;
39937   std::string *arg1 = 0 ;
39938   Dali::Toolkit::ImageView result;
39939
39940   if (!jarg1) {
39941     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
39942     return 0;
39943   }
39944   std::string arg1_str(jarg1);
39945   arg1 = &arg1_str;
39946   {
39947     try {
39948       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
39949     } CALL_CATCH_EXCEPTION(0);
39950   }
39951
39952   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
39953
39954   //argout typemap for const std::string&
39955
39956   return jresult;
39957 }
39958
39959
39960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
39961   void * jresult ;
39962   std::string *arg1 = 0 ;
39963   Dali::ImageDimensions arg2 ;
39964   Dali::ImageDimensions *argp2 ;
39965   Dali::Toolkit::ImageView result;
39966
39967   if (!jarg1) {
39968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
39969     return 0;
39970   }
39971   std::string arg1_str(jarg1);
39972   arg1 = &arg1_str;
39973   argp2 = (Dali::ImageDimensions *)jarg2;
39974   if (!argp2) {
39975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
39976     return 0;
39977   }
39978   arg2 = *argp2;
39979   {
39980     try {
39981       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
39982     } CALL_CATCH_EXCEPTION(0);
39983   }
39984
39985   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
39986
39987   //argout typemap for const std::string&
39988
39989   return jresult;
39990 }
39991
39992
39993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
39994   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
39995
39996   arg1 = (Dali::Toolkit::ImageView *)jarg1;
39997   {
39998     try {
39999       delete arg1;
40000     } CALL_CATCH_EXCEPTION();
40001   }
40002
40003 }
40004
40005
40006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
40007   void * jresult ;
40008   Dali::Toolkit::ImageView *arg1 = 0 ;
40009   Dali::Toolkit::ImageView *result = 0 ;
40010
40011   arg1 = (Dali::Toolkit::ImageView *)jarg1;
40012   if (!arg1) {
40013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
40014     return 0;
40015   }
40016   {
40017     try {
40018       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
40019     } CALL_CATCH_EXCEPTION(0);
40020   }
40021
40022   jresult = (void *)result;
40023   return jresult;
40024 }
40025
40026
40027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
40028   void * jresult ;
40029   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
40030   Dali::Toolkit::ImageView *arg2 = 0 ;
40031   Dali::Toolkit::ImageView *result = 0 ;
40032
40033   arg1 = (Dali::Toolkit::ImageView *)jarg1;
40034   arg2 = (Dali::Toolkit::ImageView *)jarg2;
40035   if (!arg2) {
40036     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
40037     return 0;
40038   }
40039   {
40040     try {
40041       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
40042     } CALL_CATCH_EXCEPTION(0);
40043   }
40044
40045   jresult = (void *)result;
40046   return jresult;
40047 }
40048
40049
40050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
40051   void * jresult ;
40052   Dali::BaseHandle arg1 ;
40053   Dali::BaseHandle *argp1 ;
40054   Dali::Toolkit::ImageView result;
40055
40056   argp1 = (Dali::BaseHandle *)jarg1;
40057   if (!argp1) {
40058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40059     return 0;
40060   }
40061   arg1 = *argp1;
40062   {
40063     try {
40064       result = Dali::Toolkit::ImageView::DownCast(arg1);
40065     } CALL_CATCH_EXCEPTION(0);
40066   }
40067
40068   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
40069   return jresult;
40070 }
40071
40072
40073 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
40074   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
40075   std::string *arg2 = 0 ;
40076
40077   arg1 = (Dali::Toolkit::ImageView *)jarg1;
40078   if (!jarg2) {
40079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
40080     return ;
40081   }
40082   std::string arg2_str(jarg2);
40083   arg2 = &arg2_str;
40084   {
40085     try {
40086       (arg1)->SetImage((std::string const &)*arg2);
40087     } CALL_CATCH_EXCEPTION();
40088   }
40089
40090
40091   //argout typemap for const std::string&
40092
40093 }
40094
40095
40096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
40097   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
40098   std::string *arg2 = 0 ;
40099   Dali::ImageDimensions arg3 ;
40100   Dali::ImageDimensions *argp3 ;
40101
40102   arg1 = (Dali::Toolkit::ImageView *)jarg1;
40103   if (!jarg2) {
40104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
40105     return ;
40106   }
40107   std::string arg2_str(jarg2);
40108   arg2 = &arg2_str;
40109   argp3 = (Dali::ImageDimensions *)jarg3;
40110   if (!argp3) {
40111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
40112     return ;
40113   }
40114   arg3 = *argp3;
40115   {
40116     try {
40117       (arg1)->SetImage((std::string const &)*arg2,arg3);
40118     } CALL_CATCH_EXCEPTION();
40119   }
40120
40121
40122   //argout typemap for const std::string&
40123
40124 }
40125
40126
40127 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_GEOMETRY_URL_get() {
40128   int jresult ;
40129   int result;
40130
40131   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
40132   jresult = (int)result;
40133   return jresult;
40134 }
40135
40136
40137 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_MATERIAL_URL_get() {
40138   int jresult ;
40139   int result;
40140
40141   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
40142   jresult = (int)result;
40143   return jresult;
40144 }
40145
40146
40147 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_IMAGES_URL_get() {
40148   int jresult ;
40149   int result;
40150
40151   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
40152   jresult = (int)result;
40153   return jresult;
40154 }
40155
40156
40157 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_ILLUMINATION_TYPE_get() {
40158   int jresult ;
40159   int result;
40160
40161   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
40162   jresult = (int)result;
40163   return jresult;
40164 }
40165
40166
40167 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE0_URL_get() {
40168   int jresult ;
40169   int result;
40170
40171   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
40172   jresult = (int)result;
40173   return jresult;
40174 }
40175
40176
40177 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE1_URL_get() {
40178   int jresult ;
40179   int result;
40180
40181   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
40182   jresult = (int)result;
40183   return jresult;
40184 }
40185
40186
40187 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE2_URL_get() {
40188   int jresult ;
40189   int result;
40190
40191   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
40192   jresult = (int)result;
40193   return jresult;
40194 }
40195
40196
40197 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_LIGHT_POSITION_get() {
40198   int jresult ;
40199   int result;
40200
40201   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
40202   jresult = (int)result;
40203   return jresult;
40204 }
40205
40206
40207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView_Property() {
40208   void * jresult ;
40209   Dali::Toolkit::Model3dView::Property *result = 0 ;
40210
40211   {
40212     try {
40213       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
40214     } CALL_CATCH_EXCEPTION(0);
40215   }
40216
40217   jresult = (void *)result;
40218   return jresult;
40219 }
40220
40221
40222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView_Property(void * jarg1) {
40223   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
40224
40225   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
40226   {
40227     try {
40228       delete arg1;
40229     } CALL_CATCH_EXCEPTION();
40230   }
40231
40232 }
40233
40234
40235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_0() {
40236   void * jresult ;
40237   Dali::Toolkit::Model3dView result;
40238
40239   {
40240     try {
40241       result = Dali::Toolkit::Model3dView::New();
40242     } CALL_CATCH_EXCEPTION(0);
40243   }
40244
40245   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
40246   return jresult;
40247 }
40248
40249
40250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
40251   void * jresult ;
40252   std::string *arg1 = 0 ;
40253   std::string *arg2 = 0 ;
40254   std::string *arg3 = 0 ;
40255   Dali::Toolkit::Model3dView result;
40256
40257   if (!jarg1) {
40258     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
40259     return 0;
40260   }
40261   std::string arg1_str(jarg1);
40262   arg1 = &arg1_str;
40263   if (!jarg2) {
40264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
40265     return 0;
40266   }
40267   std::string arg2_str(jarg2);
40268   arg2 = &arg2_str;
40269   if (!jarg3) {
40270     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
40271     return 0;
40272   }
40273   std::string arg3_str(jarg3);
40274   arg3 = &arg3_str;
40275   {
40276     try {
40277       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
40278     } CALL_CATCH_EXCEPTION(0);
40279   }
40280
40281   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
40282
40283   //argout typemap for const std::string&
40284
40285
40286   //argout typemap for const std::string&
40287
40288
40289   //argout typemap for const std::string&
40290
40291   return jresult;
40292 }
40293
40294
40295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_0() {
40296   void * jresult ;
40297   Dali::Toolkit::Model3dView *result = 0 ;
40298
40299   {
40300     try {
40301       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
40302     } CALL_CATCH_EXCEPTION(0);
40303   }
40304
40305   jresult = (void *)result;
40306   return jresult;
40307 }
40308
40309
40310 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView(void * jarg1) {
40311   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
40312
40313   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
40314   {
40315     try {
40316       delete arg1;
40317     } CALL_CATCH_EXCEPTION();
40318   }
40319
40320 }
40321
40322
40323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_1(void * jarg1) {
40324   void * jresult ;
40325   Dali::Toolkit::Model3dView *arg1 = 0 ;
40326   Dali::Toolkit::Model3dView *result = 0 ;
40327
40328   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
40329   if (!arg1) {
40330     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
40331     return 0;
40332   }
40333   {
40334     try {
40335       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
40336     } CALL_CATCH_EXCEPTION(0);
40337   }
40338
40339   jresult = (void *)result;
40340   return jresult;
40341 }
40342
40343
40344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_Assign(void * jarg1, void * jarg2) {
40345   void * jresult ;
40346   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
40347   Dali::Toolkit::Model3dView *arg2 = 0 ;
40348   Dali::Toolkit::Model3dView *result = 0 ;
40349
40350   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
40351   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
40352   if (!arg2) {
40353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
40354     return 0;
40355   }
40356   {
40357     try {
40358       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
40359     } CALL_CATCH_EXCEPTION(0);
40360   }
40361
40362   jresult = (void *)result;
40363   return jresult;
40364 }
40365
40366
40367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_DownCast(void * jarg1) {
40368   void * jresult ;
40369   Dali::BaseHandle arg1 ;
40370   Dali::BaseHandle *argp1 ;
40371   Dali::Toolkit::Model3dView result;
40372
40373   argp1 = (Dali::BaseHandle *)jarg1;
40374   if (!argp1) {
40375     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40376     return 0;
40377   }
40378   arg1 = *argp1;
40379   {
40380     try {
40381       result = Dali::Toolkit::Model3dView::DownCast(arg1);
40382     } CALL_CATCH_EXCEPTION(0);
40383   }
40384
40385   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
40386   return jresult;
40387 }
40388
40389
40390 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
40391   int jresult ;
40392   int result;
40393
40394   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
40395   jresult = (int)result;
40396   return jresult;
40397 }
40398
40399
40400 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
40401   int jresult ;
40402   int result;
40403
40404   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
40405   jresult = (int)result;
40406   return jresult;
40407 }
40408
40409
40410 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
40411   int jresult ;
40412   int result;
40413
40414   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
40415   jresult = (int)result;
40416   return jresult;
40417 }
40418
40419
40420 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
40421   int jresult ;
40422   int result;
40423
40424   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
40425   jresult = (int)result;
40426   return jresult;
40427 }
40428
40429
40430 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
40431   int jresult ;
40432   int result;
40433
40434   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
40435   jresult = (int)result;
40436   return jresult;
40437 }
40438
40439
40440 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
40441   int jresult ;
40442   int result;
40443
40444   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
40445   jresult = (int)result;
40446   return jresult;
40447 }
40448
40449
40450 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
40451   int jresult ;
40452   int result;
40453
40454   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
40455   jresult = (int)result;
40456   return jresult;
40457 }
40458
40459
40460 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
40461   int jresult ;
40462   int result;
40463
40464   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
40465   jresult = (int)result;
40466   return jresult;
40467 }
40468
40469
40470 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
40471   int jresult ;
40472   int result;
40473
40474   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
40475   jresult = (int)result;
40476   return jresult;
40477 }
40478
40479
40480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
40481   void * jresult ;
40482   Dali::Toolkit::ScrollBar::Property *result = 0 ;
40483
40484   {
40485     try {
40486       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
40487     } CALL_CATCH_EXCEPTION(0);
40488   }
40489
40490   jresult = (void *)result;
40491   return jresult;
40492 }
40493
40494
40495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
40496   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
40497
40498   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
40499   {
40500     try {
40501       delete arg1;
40502     } CALL_CATCH_EXCEPTION();
40503   }
40504
40505 }
40506
40507
40508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
40509   void * jresult ;
40510   Dali::Toolkit::ScrollBar *result = 0 ;
40511
40512   {
40513     try {
40514       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
40515     } CALL_CATCH_EXCEPTION(0);
40516   }
40517
40518   jresult = (void *)result;
40519   return jresult;
40520 }
40521
40522
40523 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
40524   void * jresult ;
40525   Dali::Toolkit::ScrollBar *arg1 = 0 ;
40526   Dali::Toolkit::ScrollBar *result = 0 ;
40527
40528   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40529   if (!arg1) {
40530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
40531     return 0;
40532   }
40533   {
40534     try {
40535       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
40536     } CALL_CATCH_EXCEPTION(0);
40537   }
40538
40539   jresult = (void *)result;
40540   return jresult;
40541 }
40542
40543
40544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
40545   void * jresult ;
40546   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40547   Dali::Toolkit::ScrollBar *arg2 = 0 ;
40548   Dali::Toolkit::ScrollBar *result = 0 ;
40549
40550   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40551   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
40552   if (!arg2) {
40553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
40554     return 0;
40555   }
40556   {
40557     try {
40558       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
40559     } CALL_CATCH_EXCEPTION(0);
40560   }
40561
40562   jresult = (void *)result;
40563   return jresult;
40564 }
40565
40566
40567 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
40568   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40569
40570   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40571   {
40572     try {
40573       delete arg1;
40574     } CALL_CATCH_EXCEPTION();
40575   }
40576
40577 }
40578
40579
40580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
40581   void * jresult ;
40582   Dali::Toolkit::ScrollBar::Direction arg1 ;
40583   Dali::Toolkit::ScrollBar result;
40584
40585   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
40586   {
40587     try {
40588       result = Dali::Toolkit::ScrollBar::New(arg1);
40589     } CALL_CATCH_EXCEPTION(0);
40590   }
40591
40592   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
40593   return jresult;
40594 }
40595
40596
40597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
40598   void * jresult ;
40599   Dali::Toolkit::ScrollBar result;
40600
40601   {
40602     try {
40603       result = Dali::Toolkit::ScrollBar::New();
40604     } CALL_CATCH_EXCEPTION(0);
40605   }
40606
40607   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
40608   return jresult;
40609 }
40610
40611
40612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
40613   void * jresult ;
40614   Dali::BaseHandle arg1 ;
40615   Dali::BaseHandle *argp1 ;
40616   Dali::Toolkit::ScrollBar result;
40617
40618   argp1 = (Dali::BaseHandle *)jarg1;
40619   if (!argp1) {
40620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40621     return 0;
40622   }
40623   arg1 = *argp1;
40624   {
40625     try {
40626       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
40627     } CALL_CATCH_EXCEPTION(0);
40628   }
40629
40630   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
40631   return jresult;
40632 }
40633
40634
40635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
40636   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40637   Dali::Handle arg2 ;
40638   Dali::Property::Index arg3 ;
40639   Dali::Property::Index arg4 ;
40640   Dali::Property::Index arg5 ;
40641   Dali::Property::Index arg6 ;
40642   Dali::Handle *argp2 ;
40643
40644   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40645   argp2 = (Dali::Handle *)jarg2;
40646   if (!argp2) {
40647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
40648     return ;
40649   }
40650   arg2 = *argp2;
40651   arg3 = (Dali::Property::Index)jarg3;
40652   arg4 = (Dali::Property::Index)jarg4;
40653   arg5 = (Dali::Property::Index)jarg5;
40654   arg6 = (Dali::Property::Index)jarg6;
40655   {
40656     try {
40657       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
40658     } CALL_CATCH_EXCEPTION();
40659   }
40660
40661 }
40662
40663
40664 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
40665   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40666   Dali::Actor arg2 ;
40667   Dali::Actor *argp2 ;
40668
40669   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40670   argp2 = (Dali::Actor *)jarg2;
40671   if (!argp2) {
40672     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40673     return ;
40674   }
40675   arg2 = *argp2;
40676   {
40677     try {
40678       (arg1)->SetScrollIndicator(arg2);
40679     } CALL_CATCH_EXCEPTION();
40680   }
40681
40682 }
40683
40684
40685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
40686   void * jresult ;
40687   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40688   Dali::Actor result;
40689
40690   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40691   {
40692     try {
40693       result = (arg1)->GetScrollIndicator();
40694     } CALL_CATCH_EXCEPTION(0);
40695   }
40696
40697   jresult = new Dali::Actor((const Dali::Actor &)result);
40698   return jresult;
40699 }
40700
40701
40702 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
40703   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40704   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
40705
40706   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40707   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
40708   if (!arg2) {
40709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
40710     return ;
40711   }
40712   {
40713     try {
40714       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
40715     } CALL_CATCH_EXCEPTION();
40716   }
40717
40718 }
40719
40720
40721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
40722   void * jresult ;
40723   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40724
40725   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40726   {
40727     try {
40728       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()));
40729     } CALL_CATCH_EXCEPTION(0);
40730   }
40731   return jresult;
40732 }
40733
40734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
40735   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40736   Dali::Toolkit::ScrollBar::Direction arg2 ;
40737
40738   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40739   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
40740   {
40741     try {
40742       (arg1)->SetScrollDirection(arg2);
40743     } CALL_CATCH_EXCEPTION();
40744   }
40745
40746 }
40747
40748
40749 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
40750   int jresult ;
40751   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40752   Dali::Toolkit::ScrollBar::Direction result;
40753
40754   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40755   {
40756     try {
40757       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
40758     } CALL_CATCH_EXCEPTION(0);
40759   }
40760
40761   jresult = (int)result;
40762   return jresult;
40763 }
40764
40765
40766 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
40767   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40768   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
40769
40770   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40771   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
40772   {
40773     try {
40774       (arg1)->SetIndicatorHeightPolicy(arg2);
40775     } CALL_CATCH_EXCEPTION();
40776   }
40777
40778 }
40779
40780
40781 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
40782   int jresult ;
40783   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40784   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
40785
40786   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40787   {
40788     try {
40789       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
40790     } CALL_CATCH_EXCEPTION(0);
40791   }
40792
40793   jresult = (int)result;
40794   return jresult;
40795 }
40796
40797
40798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
40799   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40800   float arg2 ;
40801
40802   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40803   arg2 = (float)jarg2;
40804   {
40805     try {
40806       (arg1)->SetIndicatorFixedHeight(arg2);
40807     } CALL_CATCH_EXCEPTION();
40808   }
40809
40810 }
40811
40812
40813 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
40814   float jresult ;
40815   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40816   float result;
40817
40818   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40819   {
40820     try {
40821       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
40822     } CALL_CATCH_EXCEPTION(0);
40823   }
40824
40825   jresult = result;
40826   return jresult;
40827 }
40828
40829
40830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
40831   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40832   float arg2 ;
40833
40834   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40835   arg2 = (float)jarg2;
40836   {
40837     try {
40838       (arg1)->SetIndicatorShowDuration(arg2);
40839     } CALL_CATCH_EXCEPTION();
40840   }
40841
40842 }
40843
40844
40845 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
40846   float jresult ;
40847   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40848   float result;
40849
40850   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40851   {
40852     try {
40853       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
40854     } CALL_CATCH_EXCEPTION(0);
40855   }
40856
40857   jresult = result;
40858   return jresult;
40859 }
40860
40861
40862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
40863   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40864   float arg2 ;
40865
40866   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40867   arg2 = (float)jarg2;
40868   {
40869     try {
40870       (arg1)->SetIndicatorHideDuration(arg2);
40871     } CALL_CATCH_EXCEPTION();
40872   }
40873
40874 }
40875
40876
40877 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
40878   float jresult ;
40879   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40880   float result;
40881
40882   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40883   {
40884     try {
40885       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
40886     } CALL_CATCH_EXCEPTION(0);
40887   }
40888
40889   jresult = result;
40890   return jresult;
40891 }
40892
40893
40894 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
40895   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40896
40897   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40898   {
40899     try {
40900       (arg1)->ShowIndicator();
40901     } CALL_CATCH_EXCEPTION();
40902   }
40903
40904 }
40905
40906
40907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
40908   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40909
40910   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40911   {
40912     try {
40913       (arg1)->HideIndicator();
40914     } CALL_CATCH_EXCEPTION();
40915   }
40916
40917 }
40918
40919
40920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
40921   void * jresult ;
40922   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40923   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
40924
40925   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40926   {
40927     try {
40928       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
40929     } CALL_CATCH_EXCEPTION(0);
40930   }
40931
40932   jresult = (void *)result;
40933   return jresult;
40934 }
40935
40936
40937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
40938   void * jresult ;
40939   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40940   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
40941
40942   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40943   {
40944     try {
40945       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
40946     } CALL_CATCH_EXCEPTION(0);
40947   }
40948
40949   jresult = (void *)result;
40950   return jresult;
40951 }
40952
40953
40954 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
40955   int jresult ;
40956   int result;
40957
40958   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
40959   jresult = (int)result;
40960   return jresult;
40961 }
40962
40963
40964 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
40965   int jresult ;
40966   int result;
40967
40968   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
40969   jresult = (int)result;
40970   return jresult;
40971 }
40972
40973
40974 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
40975   int jresult ;
40976   int result;
40977
40978   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
40979   jresult = (int)result;
40980   return jresult;
40981 }
40982
40983
40984 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
40985   int jresult ;
40986   int result;
40987
40988   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
40989   jresult = (int)result;
40990   return jresult;
40991 }
40992
40993
40994 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
40995   int jresult ;
40996   int result;
40997
40998   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
40999   jresult = (int)result;
41000   return jresult;
41001 }
41002
41003
41004 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
41005   int jresult ;
41006   int result;
41007
41008   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
41009   jresult = (int)result;
41010   return jresult;
41011 }
41012
41013
41014 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
41015   int jresult ;
41016   int result;
41017
41018   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
41019   jresult = (int)result;
41020   return jresult;
41021 }
41022
41023
41024 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
41025   int jresult ;
41026   int result;
41027
41028   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
41029   jresult = (int)result;
41030   return jresult;
41031 }
41032
41033
41034 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
41035   int jresult ;
41036   int result;
41037
41038   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
41039   jresult = (int)result;
41040   return jresult;
41041 }
41042
41043
41044 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
41045   int jresult ;
41046   int result;
41047
41048   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
41049   jresult = (int)result;
41050   return jresult;
41051 }
41052
41053
41054 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
41055   int jresult ;
41056   int result;
41057
41058   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
41059   jresult = (int)result;
41060   return jresult;
41061 }
41062
41063
41064 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
41065   int jresult ;
41066   int result;
41067
41068   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
41069   jresult = (int)result;
41070   return jresult;
41071 }
41072
41073
41074 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
41075   int jresult ;
41076   int result;
41077
41078   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
41079   jresult = (int)result;
41080   return jresult;
41081 }
41082
41083
41084 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
41085   int jresult ;
41086   int result;
41087
41088   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
41089   jresult = (int)result;
41090   return jresult;
41091 }
41092
41093
41094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
41095   void * jresult ;
41096   Dali::Toolkit::Scrollable::Property *result = 0 ;
41097
41098   {
41099     try {
41100       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
41101     } CALL_CATCH_EXCEPTION(0);
41102   }
41103
41104   jresult = (void *)result;
41105   return jresult;
41106 }
41107
41108
41109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
41110   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
41111
41112   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
41113   {
41114     try {
41115       delete arg1;
41116     } CALL_CATCH_EXCEPTION();
41117   }
41118
41119 }
41120
41121
41122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
41123   void * jresult ;
41124   Dali::Toolkit::Scrollable *result = 0 ;
41125
41126   {
41127     try {
41128       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
41129     } CALL_CATCH_EXCEPTION(0);
41130   }
41131
41132   jresult = (void *)result;
41133   return jresult;
41134 }
41135
41136
41137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
41138   void * jresult ;
41139   Dali::Toolkit::Scrollable *arg1 = 0 ;
41140   Dali::Toolkit::Scrollable *result = 0 ;
41141
41142   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
41143   if (!arg1) {
41144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
41145     return 0;
41146   }
41147   {
41148     try {
41149       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
41150     } CALL_CATCH_EXCEPTION(0);
41151   }
41152
41153   jresult = (void *)result;
41154   return jresult;
41155 }
41156
41157
41158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
41159   void * jresult ;
41160   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
41161   Dali::Toolkit::Scrollable *arg2 = 0 ;
41162   Dali::Toolkit::Scrollable *result = 0 ;
41163
41164   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
41165   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
41166   if (!arg2) {
41167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
41168     return 0;
41169   }
41170   {
41171     try {
41172       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
41173     } CALL_CATCH_EXCEPTION(0);
41174   }
41175
41176   jresult = (void *)result;
41177   return jresult;
41178 }
41179
41180
41181 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
41182   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
41183
41184   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
41185   {
41186     try {
41187       delete arg1;
41188     } CALL_CATCH_EXCEPTION();
41189   }
41190
41191 }
41192
41193
41194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
41195   void * jresult ;
41196   Dali::BaseHandle arg1 ;
41197   Dali::BaseHandle *argp1 ;
41198   Dali::Toolkit::Scrollable result;
41199
41200   argp1 = (Dali::BaseHandle *)jarg1;
41201   if (!argp1) {
41202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41203     return 0;
41204   }
41205   arg1 = *argp1;
41206   {
41207     try {
41208       result = Dali::Toolkit::Scrollable::DownCast(arg1);
41209     } CALL_CATCH_EXCEPTION(0);
41210   }
41211
41212   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
41213   return jresult;
41214 }
41215
41216
41217 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
41218   unsigned int jresult ;
41219   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
41220   bool result;
41221
41222   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
41223   {
41224     try {
41225       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
41226     } CALL_CATCH_EXCEPTION(0);
41227   }
41228
41229   jresult = result;
41230   return jresult;
41231 }
41232
41233
41234 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
41235   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
41236   bool arg2 ;
41237
41238   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
41239   arg2 = jarg2 ? true : false;
41240   {
41241     try {
41242       (arg1)->SetOvershootEnabled(arg2);
41243     } CALL_CATCH_EXCEPTION();
41244   }
41245
41246 }
41247
41248
41249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
41250   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
41251   Dali::Vector4 *arg2 = 0 ;
41252
41253   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
41254   arg2 = (Dali::Vector4 *)jarg2;
41255   if (!arg2) {
41256     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
41257     return ;
41258   }
41259   {
41260     try {
41261       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
41262     } CALL_CATCH_EXCEPTION();
41263   }
41264
41265 }
41266
41267
41268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
41269   void * jresult ;
41270   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
41271   Dali::Vector4 result;
41272
41273   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
41274   {
41275     try {
41276       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
41277     } CALL_CATCH_EXCEPTION(0);
41278   }
41279
41280   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
41281   return jresult;
41282 }
41283
41284
41285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
41286   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
41287   float arg2 ;
41288
41289   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
41290   arg2 = (float)jarg2;
41291   {
41292     try {
41293       (arg1)->SetOvershootAnimationSpeed(arg2);
41294     } CALL_CATCH_EXCEPTION();
41295   }
41296
41297 }
41298
41299
41300 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
41301   float jresult ;
41302   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
41303   float result;
41304
41305   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
41306   {
41307     try {
41308       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
41309     } CALL_CATCH_EXCEPTION(0);
41310   }
41311
41312   jresult = result;
41313   return jresult;
41314 }
41315
41316
41317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
41318   void * jresult ;
41319   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
41320   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
41321
41322   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
41323   {
41324     try {
41325       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
41326     } CALL_CATCH_EXCEPTION(0);
41327   }
41328
41329   jresult = (void *)result;
41330   return jresult;
41331 }
41332
41333
41334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
41335   void * jresult ;
41336   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
41337   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
41338
41339   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
41340   {
41341     try {
41342       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
41343     } CALL_CATCH_EXCEPTION(0);
41344   }
41345
41346   jresult = (void *)result;
41347   return jresult;
41348 }
41349
41350
41351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
41352   void * jresult ;
41353   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
41354   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
41355
41356   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
41357   {
41358     try {
41359       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
41360     } CALL_CATCH_EXCEPTION(0);
41361   }
41362
41363   jresult = (void *)result;
41364   return jresult;
41365 }
41366
41367
41368 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
41369   unsigned int jresult ;
41370   Dali::Toolkit::ControlOrientation::Type arg1 ;
41371   bool result;
41372
41373   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
41374   {
41375     try {
41376       result = (bool)Dali::Toolkit::IsVertical(arg1);
41377     } CALL_CATCH_EXCEPTION(0);
41378   }
41379
41380   jresult = result;
41381   return jresult;
41382 }
41383
41384
41385 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
41386   unsigned int jresult ;
41387   Dali::Toolkit::ControlOrientation::Type arg1 ;
41388   bool result;
41389
41390   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
41391   {
41392     try {
41393       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
41394     } CALL_CATCH_EXCEPTION(0);
41395   }
41396
41397   jresult = result;
41398   return jresult;
41399 }
41400
41401
41402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
41403   void * jresult ;
41404   unsigned int arg1 ;
41405   unsigned int arg2 ;
41406   Dali::Toolkit::ItemRange *result = 0 ;
41407
41408   arg1 = (unsigned int)jarg1;
41409   arg2 = (unsigned int)jarg2;
41410   {
41411     try {
41412       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
41413     } CALL_CATCH_EXCEPTION(0);
41414   }
41415
41416   jresult = (void *)result;
41417   return jresult;
41418 }
41419
41420
41421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
41422   void * jresult ;
41423   Dali::Toolkit::ItemRange *arg1 = 0 ;
41424   Dali::Toolkit::ItemRange *result = 0 ;
41425
41426   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
41427   if (!arg1) {
41428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
41429     return 0;
41430   }
41431   {
41432     try {
41433       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
41434     } CALL_CATCH_EXCEPTION(0);
41435   }
41436
41437   jresult = (void *)result;
41438   return jresult;
41439 }
41440
41441
41442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
41443   void * jresult ;
41444   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
41445   Dali::Toolkit::ItemRange *arg2 = 0 ;
41446   Dali::Toolkit::ItemRange *result = 0 ;
41447
41448   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
41449   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
41450   if (!arg2) {
41451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
41452     return 0;
41453   }
41454   {
41455     try {
41456       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
41457     } CALL_CATCH_EXCEPTION(0);
41458   }
41459
41460   jresult = (void *)result;
41461   return jresult;
41462 }
41463
41464
41465 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
41466   unsigned int jresult ;
41467   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
41468   unsigned int arg2 ;
41469   bool result;
41470
41471   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
41472   arg2 = (unsigned int)jarg2;
41473   {
41474     try {
41475       result = (bool)(arg1)->Within(arg2);
41476     } CALL_CATCH_EXCEPTION(0);
41477   }
41478
41479   jresult = result;
41480   return jresult;
41481 }
41482
41483
41484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
41485   void * jresult ;
41486   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
41487   Dali::Toolkit::ItemRange *arg2 = 0 ;
41488   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
41489
41490   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
41491   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
41492   if (!arg2) {
41493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
41494     return 0;
41495   }
41496   {
41497     try {
41498       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
41499     } CALL_CATCH_EXCEPTION(0);
41500   }
41501
41502   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
41503   return jresult;
41504 }
41505
41506
41507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
41508   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
41509   unsigned int arg2 ;
41510
41511   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
41512   arg2 = (unsigned int)jarg2;
41513   if (arg1) (arg1)->begin = arg2;
41514 }
41515
41516
41517 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
41518   unsigned int jresult ;
41519   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
41520   unsigned int result;
41521
41522   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
41523   result = (unsigned int) ((arg1)->begin);
41524   jresult = result;
41525   return jresult;
41526 }
41527
41528
41529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
41530   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
41531   unsigned int arg2 ;
41532
41533   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
41534   arg2 = (unsigned int)jarg2;
41535   if (arg1) (arg1)->end = arg2;
41536 }
41537
41538
41539 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
41540   unsigned int jresult ;
41541   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
41542   unsigned int result;
41543
41544   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
41545   result = (unsigned int) ((arg1)->end);
41546   jresult = result;
41547   return jresult;
41548 }
41549
41550
41551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
41552   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
41553
41554   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
41555   {
41556     try {
41557       delete arg1;
41558     } CALL_CATCH_EXCEPTION();
41559   }
41560
41561 }
41562
41563
41564 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
41565   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41566
41567   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41568   {
41569     try {
41570       delete arg1;
41571     } CALL_CATCH_EXCEPTION();
41572   }
41573
41574 }
41575
41576
41577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
41578   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41579   Dali::Toolkit::ControlOrientation::Type arg2 ;
41580
41581   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41582   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
41583   {
41584     try {
41585       (arg1)->SetOrientation(arg2);
41586     } CALL_CATCH_EXCEPTION();
41587   }
41588
41589 }
41590
41591
41592 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
41593   int jresult ;
41594   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41595   Dali::Toolkit::ControlOrientation::Type result;
41596
41597   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41598   {
41599     try {
41600       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
41601     } CALL_CATCH_EXCEPTION(0);
41602   }
41603
41604   jresult = (int)result;
41605   return jresult;
41606 }
41607
41608
41609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
41610   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41611   Dali::Property::Map *arg2 = 0 ;
41612
41613   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41614   arg2 = (Dali::Property::Map *)jarg2;
41615   if (!arg2) {
41616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
41617     return ;
41618   }
41619   {
41620     try {
41621       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
41622     } CALL_CATCH_EXCEPTION();
41623   }
41624
41625 }
41626
41627
41628 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
41629   void * jresult ;
41630   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41631   Dali::Property::Map result;
41632
41633   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41634   {
41635     try {
41636       result = (arg1)->GetLayoutProperties();
41637     } CALL_CATCH_EXCEPTION(0);
41638   }
41639
41640   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
41641   return jresult;
41642 }
41643
41644
41645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
41646   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41647   unsigned int arg2 ;
41648   Dali::Vector3 *arg3 = 0 ;
41649   Dali::Vector3 *arg4 = 0 ;
41650
41651   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41652   arg2 = (unsigned int)jarg2;
41653   arg3 = (Dali::Vector3 *)jarg3;
41654   if (!arg3) {
41655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
41656     return ;
41657   }
41658   arg4 = (Dali::Vector3 *)jarg4;
41659   if (!arg4) {
41660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
41661     return ;
41662   }
41663   {
41664     try {
41665       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
41666     } CALL_CATCH_EXCEPTION();
41667   }
41668
41669 }
41670
41671
41672 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
41673   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41674   Dali::Vector3 *arg2 = 0 ;
41675
41676   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41677   arg2 = (Dali::Vector3 *)jarg2;
41678   if (!arg2) {
41679     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
41680     return ;
41681   }
41682   {
41683     try {
41684       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
41685     } CALL_CATCH_EXCEPTION();
41686   }
41687
41688 }
41689
41690
41691 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
41692   float jresult ;
41693   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41694   unsigned int arg2 ;
41695   Dali::Vector3 arg3 ;
41696   Dali::Vector3 *argp3 ;
41697   float result;
41698
41699   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41700   arg2 = (unsigned int)jarg2;
41701   argp3 = (Dali::Vector3 *)jarg3;
41702   if (!argp3) {
41703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
41704     return 0;
41705   }
41706   arg3 = *argp3;
41707   {
41708     try {
41709       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
41710     } CALL_CATCH_EXCEPTION(0);
41711   }
41712
41713   jresult = result;
41714   return jresult;
41715 }
41716
41717
41718 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
41719   float jresult ;
41720   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41721   float arg2 ;
41722   float result;
41723
41724   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41725   arg2 = (float)jarg2;
41726   {
41727     try {
41728       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
41729     } CALL_CATCH_EXCEPTION(0);
41730   }
41731
41732   jresult = result;
41733   return jresult;
41734 }
41735
41736
41737 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
41738   float jresult ;
41739   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41740   unsigned int arg2 ;
41741   float result;
41742
41743   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41744   arg2 = (unsigned int)jarg2;
41745   {
41746     try {
41747       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
41748     } CALL_CATCH_EXCEPTION(0);
41749   }
41750
41751   jresult = result;
41752   return jresult;
41753 }
41754
41755
41756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
41757   void * jresult ;
41758   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41759   float arg2 ;
41760   Dali::Vector3 arg3 ;
41761   Dali::Vector3 *argp3 ;
41762   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
41763
41764   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41765   arg2 = (float)jarg2;
41766   argp3 = (Dali::Vector3 *)jarg3;
41767   if (!argp3) {
41768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
41769     return 0;
41770   }
41771   arg3 = *argp3;
41772   {
41773     try {
41774       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
41775     } CALL_CATCH_EXCEPTION(0);
41776   }
41777
41778   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
41779   return jresult;
41780 }
41781
41782
41783 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
41784   float jresult ;
41785   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41786   int arg2 ;
41787   float arg3 ;
41788   Dali::Vector3 *arg4 = 0 ;
41789   float result;
41790
41791   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41792   arg2 = (int)jarg2;
41793   arg3 = (float)jarg3;
41794   arg4 = (Dali::Vector3 *)jarg4;
41795   if (!arg4) {
41796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
41797     return 0;
41798   }
41799   {
41800     try {
41801       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
41802     } CALL_CATCH_EXCEPTION(0);
41803   }
41804
41805   jresult = result;
41806   return jresult;
41807 }
41808
41809
41810 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
41811   unsigned int jresult ;
41812   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41813   Dali::Vector3 arg2 ;
41814   Dali::Vector3 *argp2 ;
41815   unsigned int result;
41816
41817   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41818   argp2 = (Dali::Vector3 *)jarg2;
41819   if (!argp2) {
41820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
41821     return 0;
41822   }
41823   arg2 = *argp2;
41824   {
41825     try {
41826       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
41827     } CALL_CATCH_EXCEPTION(0);
41828   }
41829
41830   jresult = result;
41831   return jresult;
41832 }
41833
41834
41835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
41836   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41837   unsigned int arg2 ;
41838   Dali::Vector3 *arg3 = 0 ;
41839   Dali::Vector3 *arg4 = 0 ;
41840
41841   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41842   arg2 = (unsigned int)jarg2;
41843   arg3 = (Dali::Vector3 *)jarg3;
41844   if (!arg3) {
41845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
41846     return ;
41847   }
41848   arg4 = (Dali::Vector3 *)jarg4;
41849   if (!arg4) {
41850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
41851     return ;
41852   }
41853   {
41854     try {
41855       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
41856     } CALL_CATCH_EXCEPTION();
41857   }
41858
41859 }
41860
41861
41862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
41863   void * jresult ;
41864   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41865   Dali::Degree result;
41866
41867   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41868   {
41869     try {
41870       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
41871     } CALL_CATCH_EXCEPTION(0);
41872   }
41873
41874   jresult = new Dali::Degree((const Dali::Degree &)result);
41875   return jresult;
41876 }
41877
41878
41879 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
41880   float jresult ;
41881   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41882   float result;
41883
41884   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41885   {
41886     try {
41887       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
41888     } CALL_CATCH_EXCEPTION(0);
41889   }
41890
41891   jresult = result;
41892   return jresult;
41893 }
41894
41895
41896 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
41897   float jresult ;
41898   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41899   float result;
41900
41901   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41902   {
41903     try {
41904       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
41905     } CALL_CATCH_EXCEPTION(0);
41906   }
41907
41908   jresult = result;
41909   return jresult;
41910 }
41911
41912
41913 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
41914   float jresult ;
41915   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41916   float result;
41917
41918   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41919   {
41920     try {
41921       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
41922     } CALL_CATCH_EXCEPTION(0);
41923   }
41924
41925   jresult = result;
41926   return jresult;
41927 }
41928
41929
41930 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
41931   int jresult ;
41932   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41933   int arg2 ;
41934   int arg3 ;
41935   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
41936   bool arg5 ;
41937   int result;
41938
41939   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41940   arg2 = (int)jarg2;
41941   arg3 = (int)jarg3;
41942   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
41943   arg5 = jarg5 ? true : false;
41944   {
41945     try {
41946       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
41947     } CALL_CATCH_EXCEPTION(0);
41948   }
41949
41950   jresult = result;
41951   return jresult;
41952 }
41953
41954
41955 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
41956   float jresult ;
41957   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41958   float result;
41959
41960   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41961   {
41962     try {
41963       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
41964     } CALL_CATCH_EXCEPTION(0);
41965   }
41966
41967   jresult = result;
41968   return jresult;
41969 }
41970
41971
41972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
41973   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41974   Dali::Actor *arg2 = 0 ;
41975   int arg3 ;
41976   Dali::Vector3 *arg4 = 0 ;
41977   Dali::Actor *arg5 = 0 ;
41978
41979   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41980   arg2 = (Dali::Actor *)jarg2;
41981   if (!arg2) {
41982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
41983     return ;
41984   }
41985   arg3 = (int)jarg3;
41986   arg4 = (Dali::Vector3 *)jarg4;
41987   if (!arg4) {
41988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
41989     return ;
41990   }
41991   arg5 = (Dali::Actor *)jarg5;
41992   if (!arg5) {
41993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
41994     return ;
41995   }
41996   {
41997     try {
41998       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
41999     } CALL_CATCH_EXCEPTION();
42000   }
42001
42002 }
42003
42004
42005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
42006   void * jresult ;
42007   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
42008   int arg2 ;
42009   float arg3 ;
42010   Dali::Vector3 *arg4 = 0 ;
42011   Dali::Vector3 result;
42012
42013   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
42014   arg2 = (int)jarg2;
42015   arg3 = (float)jarg3;
42016   arg4 = (Dali::Vector3 *)jarg4;
42017   if (!arg4) {
42018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
42019     return 0;
42020   }
42021   {
42022     try {
42023       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
42024     } CALL_CATCH_EXCEPTION(0);
42025   }
42026
42027   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
42028   return jresult;
42029 }
42030
42031
42032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
42033   void * jresult ;
42034   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
42035   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
42036
42037   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
42038   {
42039     try {
42040       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
42041     } CALL_CATCH_EXCEPTION(0);
42042   }
42043
42044   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
42045   return jresult;
42046 }
42047
42048
42049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
42050   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
42051
42052   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
42053   {
42054     try {
42055       delete arg1;
42056     } CALL_CATCH_EXCEPTION();
42057   }
42058
42059 }
42060
42061
42062 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
42063   unsigned int jresult ;
42064   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
42065   unsigned int result;
42066
42067   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
42068   {
42069     try {
42070       result = (unsigned int)(arg1)->GetNumberOfItems();
42071     } CALL_CATCH_EXCEPTION(0);
42072   }
42073
42074   jresult = result;
42075   return jresult;
42076 }
42077
42078
42079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
42080   void * jresult ;
42081   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
42082   unsigned int arg2 ;
42083   Dali::Actor result;
42084
42085   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
42086   arg2 = (unsigned int)jarg2;
42087   {
42088     try {
42089       result = (arg1)->NewItem(arg2);
42090     } CALL_CATCH_EXCEPTION(0);
42091   }
42092
42093   jresult = new Dali::Actor((const Dali::Actor &)result);
42094   return jresult;
42095 }
42096
42097
42098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
42099   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
42100   unsigned int arg2 ;
42101   Dali::Actor arg3 ;
42102   Dali::Actor *argp3 ;
42103
42104   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
42105   arg2 = (unsigned int)jarg2;
42106   argp3 = (Dali::Actor *)jarg3;
42107   if (!argp3) {
42108     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
42109     return ;
42110   }
42111   arg3 = *argp3;
42112   {
42113     try {
42114       (arg1)->ItemReleased(arg2,arg3);
42115     } CALL_CATCH_EXCEPTION();
42116   }
42117
42118 }
42119
42120
42121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
42122   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
42123   unsigned int arg2 ;
42124   Dali::Actor arg3 ;
42125   Dali::Actor *argp3 ;
42126
42127   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
42128   arg2 = (unsigned int)jarg2;
42129   argp3 = (Dali::Actor *)jarg3;
42130   if (!argp3) {
42131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
42132     return ;
42133   }
42134   arg3 = *argp3;
42135   {
42136     try {
42137       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
42138     } CALL_CATCH_EXCEPTION();
42139   }
42140
42141 }
42142
42143
42144 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
42145   void * jresult ;
42146   Dali::Toolkit::ItemFactory *result = 0 ;
42147
42148   {
42149     try {
42150       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
42151     } CALL_CATCH_EXCEPTION(0);
42152   }
42153
42154   jresult = (void *)result;
42155   return jresult;
42156 }
42157
42158
42159 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) {
42160   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
42161   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
42162   if (director) {
42163     director->swig_connect_director(callback0, callback1, callback2);
42164   }
42165 }
42166
42167
42168 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
42169   int jresult ;
42170   int result;
42171
42172   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
42173   jresult = (int)result;
42174   return jresult;
42175 }
42176
42177
42178 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
42179   int jresult ;
42180   int result;
42181
42182   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
42183   jresult = (int)result;
42184   return jresult;
42185 }
42186
42187
42188 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
42189   int jresult ;
42190   int result;
42191
42192   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
42193   jresult = (int)result;
42194   return jresult;
42195 }
42196
42197
42198 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
42199   int jresult ;
42200   int result;
42201
42202   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
42203   jresult = (int)result;
42204   return jresult;
42205 }
42206
42207
42208 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
42209   int jresult ;
42210   int result;
42211
42212   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
42213   jresult = (int)result;
42214   return jresult;
42215 }
42216
42217
42218 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
42219   int jresult ;
42220   int result;
42221
42222   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
42223   jresult = (int)result;
42224   return jresult;
42225 }
42226
42227
42228 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
42229   int jresult ;
42230   int result;
42231
42232   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
42233   jresult = (int)result;
42234   return jresult;
42235 }
42236
42237
42238 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
42239   int jresult ;
42240   int result;
42241
42242   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
42243   jresult = (int)result;
42244   return jresult;
42245 }
42246
42247
42248 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
42249   int jresult ;
42250   int result;
42251
42252   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
42253   jresult = (int)result;
42254   return jresult;
42255 }
42256
42257
42258 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
42259   int jresult ;
42260   int result;
42261
42262   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
42263   jresult = (int)result;
42264   return jresult;
42265 }
42266
42267
42268 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
42269   int jresult ;
42270   int result;
42271
42272   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
42273   jresult = (int)result;
42274   return jresult;
42275 }
42276
42277
42278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
42279   void * jresult ;
42280   Dali::Toolkit::ItemView::Property *result = 0 ;
42281
42282   {
42283     try {
42284       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
42285     } CALL_CATCH_EXCEPTION(0);
42286   }
42287
42288   jresult = (void *)result;
42289   return jresult;
42290 }
42291
42292
42293 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
42294   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
42295
42296   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
42297   {
42298     try {
42299       delete arg1;
42300     } CALL_CATCH_EXCEPTION();
42301   }
42302
42303 }
42304
42305
42306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
42307   void * jresult ;
42308   Dali::Toolkit::ItemView *result = 0 ;
42309
42310   {
42311     try {
42312       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
42313     } CALL_CATCH_EXCEPTION(0);
42314   }
42315
42316   jresult = (void *)result;
42317   return jresult;
42318 }
42319
42320
42321 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
42322   void * jresult ;
42323   Dali::Toolkit::ItemView *arg1 = 0 ;
42324   Dali::Toolkit::ItemView *result = 0 ;
42325
42326   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42327   if (!arg1) {
42328     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
42329     return 0;
42330   }
42331   {
42332     try {
42333       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
42334     } CALL_CATCH_EXCEPTION(0);
42335   }
42336
42337   jresult = (void *)result;
42338   return jresult;
42339 }
42340
42341
42342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
42343   void * jresult ;
42344   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42345   Dali::Toolkit::ItemView *arg2 = 0 ;
42346   Dali::Toolkit::ItemView *result = 0 ;
42347
42348   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42349   arg2 = (Dali::Toolkit::ItemView *)jarg2;
42350   if (!arg2) {
42351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
42352     return 0;
42353   }
42354   {
42355     try {
42356       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
42357     } CALL_CATCH_EXCEPTION(0);
42358   }
42359
42360   jresult = (void *)result;
42361   return jresult;
42362 }
42363
42364
42365 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
42366   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42367
42368   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42369   {
42370     try {
42371       delete arg1;
42372     } CALL_CATCH_EXCEPTION();
42373   }
42374
42375 }
42376
42377
42378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
42379   void * jresult ;
42380   Dali::Toolkit::ItemFactory *arg1 = 0 ;
42381   Dali::Toolkit::ItemView result;
42382
42383   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
42384   if (!arg1) {
42385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
42386     return 0;
42387   }
42388   {
42389     try {
42390       result = Dali::Toolkit::ItemView::New(*arg1);
42391     } CALL_CATCH_EXCEPTION(0);
42392   }
42393
42394   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
42395   return jresult;
42396 }
42397
42398
42399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
42400   void * jresult ;
42401   Dali::BaseHandle arg1 ;
42402   Dali::BaseHandle *argp1 ;
42403   Dali::Toolkit::ItemView result;
42404
42405   argp1 = (Dali::BaseHandle *)jarg1;
42406   if (!argp1) {
42407     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42408     return 0;
42409   }
42410   arg1 = *argp1;
42411   {
42412     try {
42413       result = Dali::Toolkit::ItemView::DownCast(arg1);
42414     } CALL_CATCH_EXCEPTION(0);
42415   }
42416
42417   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
42418   return jresult;
42419 }
42420
42421
42422 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
42423   unsigned int jresult ;
42424   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42425   unsigned int result;
42426
42427   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42428   {
42429     try {
42430       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
42431     } CALL_CATCH_EXCEPTION(0);
42432   }
42433
42434   jresult = result;
42435   return jresult;
42436 }
42437
42438
42439 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
42440   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42441   Dali::Toolkit::ItemLayout *arg2 = 0 ;
42442
42443   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42444   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
42445   if (!arg2) {
42446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
42447     return ;
42448   }
42449   {
42450     try {
42451       (arg1)->AddLayout(*arg2);
42452     } CALL_CATCH_EXCEPTION();
42453   }
42454
42455 }
42456
42457
42458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
42459   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42460   unsigned int arg2 ;
42461
42462   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42463   arg2 = (unsigned int)jarg2;
42464   {
42465     try {
42466       (arg1)->RemoveLayout(arg2);
42467     } CALL_CATCH_EXCEPTION();
42468   }
42469
42470 }
42471
42472
42473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
42474   void * jresult ;
42475   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42476   unsigned int arg2 ;
42477   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
42478
42479   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42480   arg2 = (unsigned int)jarg2;
42481   {
42482     try {
42483       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
42484     } CALL_CATCH_EXCEPTION(0);
42485   }
42486
42487   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
42488   return jresult;
42489 }
42490
42491
42492 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
42493   void * jresult ;
42494   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42495   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
42496
42497   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42498   {
42499     try {
42500       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
42501     } CALL_CATCH_EXCEPTION(0);
42502   }
42503
42504   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
42505   return jresult;
42506 }
42507
42508
42509 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
42510   float jresult ;
42511   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42512   Dali::Toolkit::ItemId arg2 ;
42513   float result;
42514
42515   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42516   arg2 = (Dali::Toolkit::ItemId)jarg2;
42517   {
42518     try {
42519       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
42520     } CALL_CATCH_EXCEPTION(0);
42521   }
42522
42523   jresult = result;
42524   return jresult;
42525 }
42526
42527
42528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
42529   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42530   unsigned int arg2 ;
42531   Dali::Vector3 arg3 ;
42532   float arg4 ;
42533   Dali::Vector3 *argp3 ;
42534
42535   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42536   arg2 = (unsigned int)jarg2;
42537   argp3 = (Dali::Vector3 *)jarg3;
42538   if (!argp3) {
42539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
42540     return ;
42541   }
42542   arg3 = *argp3;
42543   arg4 = (float)jarg4;
42544   {
42545     try {
42546       (arg1)->ActivateLayout(arg2,arg3,arg4);
42547     } CALL_CATCH_EXCEPTION();
42548   }
42549
42550 }
42551
42552
42553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
42554   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42555
42556   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42557   {
42558     try {
42559       (arg1)->DeactivateCurrentLayout();
42560     } CALL_CATCH_EXCEPTION();
42561   }
42562
42563 }
42564
42565
42566 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
42567   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42568   float arg2 ;
42569
42570   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42571   arg2 = (float)jarg2;
42572   {
42573     try {
42574       (arg1)->SetMinimumSwipeSpeed(arg2);
42575     } CALL_CATCH_EXCEPTION();
42576   }
42577
42578 }
42579
42580
42581 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
42582   float jresult ;
42583   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42584   float result;
42585
42586   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42587   {
42588     try {
42589       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
42590     } CALL_CATCH_EXCEPTION(0);
42591   }
42592
42593   jresult = result;
42594   return jresult;
42595 }
42596
42597
42598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
42599   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42600   float arg2 ;
42601
42602   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42603   arg2 = (float)jarg2;
42604   {
42605     try {
42606       (arg1)->SetMinimumSwipeDistance(arg2);
42607     } CALL_CATCH_EXCEPTION();
42608   }
42609
42610 }
42611
42612
42613 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
42614   float jresult ;
42615   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42616   float result;
42617
42618   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42619   {
42620     try {
42621       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
42622     } CALL_CATCH_EXCEPTION(0);
42623   }
42624
42625   jresult = result;
42626   return jresult;
42627 }
42628
42629
42630 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
42631   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42632   float arg2 ;
42633
42634   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42635   arg2 = (float)jarg2;
42636   {
42637     try {
42638       (arg1)->SetWheelScrollDistanceStep(arg2);
42639     } CALL_CATCH_EXCEPTION();
42640   }
42641
42642 }
42643
42644
42645 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
42646   float jresult ;
42647   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42648   float result;
42649
42650   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42651   {
42652     try {
42653       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
42654     } CALL_CATCH_EXCEPTION(0);
42655   }
42656
42657   jresult = result;
42658   return jresult;
42659 }
42660
42661
42662 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
42663   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42664   bool arg2 ;
42665
42666   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42667   arg2 = jarg2 ? true : false;
42668   {
42669     try {
42670       (arg1)->SetAnchoring(arg2);
42671     } CALL_CATCH_EXCEPTION();
42672   }
42673
42674 }
42675
42676 //// ========================= end of part 3 =============================
42677
42678 //// ========================== start part 4 ===============================
42679
42680
42681 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
42682   unsigned int jresult ;
42683   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42684   bool result;
42685
42686   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42687   {
42688     try {
42689       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
42690     } CALL_CATCH_EXCEPTION(0);
42691   }
42692
42693   jresult = result;
42694   return jresult;
42695 }
42696
42697
42698 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
42699   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42700   float arg2 ;
42701
42702   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42703   arg2 = (float)jarg2;
42704   {
42705     try {
42706       (arg1)->SetAnchoringDuration(arg2);
42707     } CALL_CATCH_EXCEPTION();
42708   }
42709
42710 }
42711
42712
42713 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
42714   float jresult ;
42715   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42716   float result;
42717
42718   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42719   {
42720     try {
42721       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
42722     } CALL_CATCH_EXCEPTION(0);
42723   }
42724
42725   jresult = result;
42726   return jresult;
42727 }
42728
42729
42730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
42731   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42732   Dali::Toolkit::ItemId arg2 ;
42733   float arg3 ;
42734
42735   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42736   arg2 = (Dali::Toolkit::ItemId)jarg2;
42737   arg3 = (float)jarg3;
42738   {
42739     try {
42740       (arg1)->ScrollToItem(arg2,arg3);
42741     } CALL_CATCH_EXCEPTION();
42742   }
42743
42744 }
42745
42746
42747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
42748   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42749   float arg2 ;
42750
42751   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42752   arg2 = (float)jarg2;
42753   {
42754     try {
42755       (arg1)->SetRefreshInterval(arg2);
42756     } CALL_CATCH_EXCEPTION();
42757   }
42758
42759 }
42760
42761
42762 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
42763   float jresult ;
42764   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42765   float result;
42766
42767   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42768   {
42769     try {
42770       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
42771     } CALL_CATCH_EXCEPTION(0);
42772   }
42773
42774   jresult = result;
42775   return jresult;
42776 }
42777
42778
42779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
42780   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42781
42782   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42783   {
42784     try {
42785       (arg1)->Refresh();
42786     } CALL_CATCH_EXCEPTION();
42787   }
42788
42789 }
42790
42791
42792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
42793   void * jresult ;
42794   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42795   Dali::Toolkit::ItemId arg2 ;
42796   Dali::Actor result;
42797
42798   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42799   arg2 = (Dali::Toolkit::ItemId)jarg2;
42800   {
42801     try {
42802       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
42803     } CALL_CATCH_EXCEPTION(0);
42804   }
42805
42806   jresult = new Dali::Actor((const Dali::Actor &)result);
42807   return jresult;
42808 }
42809
42810
42811 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
42812   unsigned int jresult ;
42813   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42814   Dali::Actor arg2 ;
42815   Dali::Actor *argp2 ;
42816   Dali::Toolkit::ItemId result;
42817
42818   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42819   argp2 = (Dali::Actor *)jarg2;
42820   if (!argp2) {
42821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
42822     return 0;
42823   }
42824   arg2 = *argp2;
42825   {
42826     try {
42827       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
42828     } CALL_CATCH_EXCEPTION(0);
42829   }
42830
42831   jresult = result;
42832   return jresult;
42833 }
42834
42835
42836 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
42837   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42838   Dali::Toolkit::Item arg2 ;
42839   float arg3 ;
42840   Dali::Toolkit::Item *argp2 ;
42841
42842   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42843   argp2 = (Dali::Toolkit::Item *)jarg2;
42844   if (!argp2) {
42845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
42846     return ;
42847   }
42848   arg2 = *argp2;
42849   arg3 = (float)jarg3;
42850   {
42851     try {
42852       (arg1)->InsertItem(arg2,arg3);
42853     } CALL_CATCH_EXCEPTION();
42854   }
42855
42856 }
42857
42858
42859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
42860   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42861   Dali::Toolkit::ItemContainer *arg2 = 0 ;
42862   float arg3 ;
42863
42864   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42865   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
42866   if (!arg2) {
42867     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
42868     return ;
42869   }
42870   arg3 = (float)jarg3;
42871   {
42872     try {
42873       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
42874     } CALL_CATCH_EXCEPTION();
42875   }
42876
42877 }
42878
42879
42880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
42881   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42882   Dali::Toolkit::ItemId arg2 ;
42883   float arg3 ;
42884
42885   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42886   arg2 = (Dali::Toolkit::ItemId)jarg2;
42887   arg3 = (float)jarg3;
42888   {
42889     try {
42890       (arg1)->RemoveItem(arg2,arg3);
42891     } CALL_CATCH_EXCEPTION();
42892   }
42893
42894 }
42895
42896
42897 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
42898   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42899   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
42900   float arg3 ;
42901
42902   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42903   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
42904   if (!arg2) {
42905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
42906     return ;
42907   }
42908   arg3 = (float)jarg3;
42909   {
42910     try {
42911       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
42912     } CALL_CATCH_EXCEPTION();
42913   }
42914
42915 }
42916
42917
42918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
42919   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42920   Dali::Toolkit::Item arg2 ;
42921   float arg3 ;
42922   Dali::Toolkit::Item *argp2 ;
42923
42924   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42925   argp2 = (Dali::Toolkit::Item *)jarg2;
42926   if (!argp2) {
42927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
42928     return ;
42929   }
42930   arg2 = *argp2;
42931   arg3 = (float)jarg3;
42932   {
42933     try {
42934       (arg1)->ReplaceItem(arg2,arg3);
42935     } CALL_CATCH_EXCEPTION();
42936   }
42937
42938 }
42939
42940
42941 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
42942   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42943   Dali::Toolkit::ItemContainer *arg2 = 0 ;
42944   float arg3 ;
42945
42946   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42947   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
42948   if (!arg2) {
42949     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
42950     return ;
42951   }
42952   arg3 = (float)jarg3;
42953   {
42954     try {
42955       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
42956     } CALL_CATCH_EXCEPTION();
42957   }
42958
42959 }
42960
42961
42962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
42963   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42964   Dali::Vector3 *arg2 = 0 ;
42965
42966   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42967   arg2 = (Dali::Vector3 *)jarg2;
42968   if (!arg2) {
42969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
42970     return ;
42971   }
42972   {
42973     try {
42974       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
42975     } CALL_CATCH_EXCEPTION();
42976   }
42977
42978 }
42979
42980
42981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
42982   void * jresult ;
42983   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42984   Dali::Vector3 result;
42985
42986   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42987   {
42988     try {
42989       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
42990     } CALL_CATCH_EXCEPTION(0);
42991   }
42992
42993   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
42994   return jresult;
42995 }
42996
42997
42998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
42999   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
43000   Dali::Vector3 *arg2 = 0 ;
43001
43002   arg1 = (Dali::Toolkit::ItemView *)jarg1;
43003   arg2 = (Dali::Vector3 *)jarg2;
43004   if (!arg2) {
43005     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43006     return ;
43007   }
43008   {
43009     try {
43010       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
43011     } CALL_CATCH_EXCEPTION();
43012   }
43013
43014 }
43015
43016
43017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
43018   void * jresult ;
43019   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
43020   Dali::Vector3 result;
43021
43022   arg1 = (Dali::Toolkit::ItemView *)jarg1;
43023   {
43024     try {
43025       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
43026     } CALL_CATCH_EXCEPTION(0);
43027   }
43028
43029   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
43030   return jresult;
43031 }
43032
43033
43034 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
43035   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
43036   Dali::Toolkit::ItemRange *arg2 = 0 ;
43037
43038   arg1 = (Dali::Toolkit::ItemView *)jarg1;
43039   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
43040   if (!arg2) {
43041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
43042     return ;
43043   }
43044   {
43045     try {
43046       (arg1)->GetItemsRange(*arg2);
43047     } CALL_CATCH_EXCEPTION();
43048   }
43049
43050 }
43051
43052
43053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
43054   void * jresult ;
43055   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
43056   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
43057
43058   arg1 = (Dali::Toolkit::ItemView *)jarg1;
43059   {
43060     try {
43061       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
43062     } CALL_CATCH_EXCEPTION(0);
43063   }
43064
43065   jresult = (void *)result;
43066   return jresult;
43067 }
43068
43069
43070 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
43071   Dali::Vector3 *arg1 = 0 ;
43072   PropertyInputContainer *arg2 = 0 ;
43073
43074   arg1 = (Dali::Vector3 *)jarg1;
43075   if (!arg1) {
43076     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43077     return ;
43078   }
43079   arg2 = (PropertyInputContainer *)jarg2;
43080   if (!arg2) {
43081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
43082     return ;
43083   }
43084   {
43085     try {
43086       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
43087     } CALL_CATCH_EXCEPTION();
43088   }
43089
43090 }
43091
43092
43093 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
43094   Dali::Vector3 *arg1 = 0 ;
43095   PropertyInputContainer *arg2 = 0 ;
43096
43097   arg1 = (Dali::Vector3 *)jarg1;
43098   if (!arg1) {
43099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43100     return ;
43101   }
43102   arg2 = (PropertyInputContainer *)jarg2;
43103   if (!arg2) {
43104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
43105     return ;
43106   }
43107   {
43108     try {
43109       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
43110     } CALL_CATCH_EXCEPTION();
43111   }
43112
43113 }
43114
43115
43116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
43117   void * jresult ;
43118   Dali::Toolkit::ScrollViewEffect *result = 0 ;
43119
43120   {
43121     try {
43122       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
43123     } CALL_CATCH_EXCEPTION(0);
43124   }
43125
43126   jresult = (void *)result;
43127   return jresult;
43128 }
43129
43130
43131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
43132   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
43133
43134   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
43135   {
43136     try {
43137       delete arg1;
43138     } CALL_CATCH_EXCEPTION();
43139   }
43140
43141 }
43142
43143
43144 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
43145   void * jresult ;
43146   Dali::Path arg1 ;
43147   Dali::Vector3 *arg2 = 0 ;
43148   Dali::Property::Index arg3 ;
43149   Dali::Vector3 *arg4 = 0 ;
43150   unsigned int arg5 ;
43151   Dali::Path *argp1 ;
43152   Dali::Toolkit::ScrollViewPagePathEffect result;
43153
43154   argp1 = (Dali::Path *)jarg1;
43155   if (!argp1) {
43156     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
43157     return 0;
43158   }
43159   arg1 = *argp1;
43160   arg2 = (Dali::Vector3 *)jarg2;
43161   if (!arg2) {
43162     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43163     return 0;
43164   }
43165   arg3 = (Dali::Property::Index)jarg3;
43166   arg4 = (Dali::Vector3 *)jarg4;
43167   if (!arg4) {
43168     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43169     return 0;
43170   }
43171   arg5 = (unsigned int)jarg5;
43172   {
43173     try {
43174       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
43175     } CALL_CATCH_EXCEPTION(0);
43176   }
43177
43178   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
43179   return jresult;
43180 }
43181
43182
43183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
43184   void * jresult ;
43185   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
43186
43187   {
43188     try {
43189       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
43190     } CALL_CATCH_EXCEPTION(0);
43191   }
43192
43193   jresult = (void *)result;
43194   return jresult;
43195 }
43196
43197
43198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
43199   void * jresult ;
43200   Dali::BaseHandle arg1 ;
43201   Dali::BaseHandle *argp1 ;
43202   Dali::Toolkit::ScrollViewPagePathEffect result;
43203
43204   argp1 = (Dali::BaseHandle *)jarg1;
43205   if (!argp1) {
43206     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43207     return 0;
43208   }
43209   arg1 = *argp1;
43210   {
43211     try {
43212       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
43213     } CALL_CATCH_EXCEPTION(0);
43214   }
43215
43216   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
43217   return jresult;
43218 }
43219
43220
43221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
43222   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
43223   Dali::Actor arg2 ;
43224   unsigned int arg3 ;
43225   Dali::Actor *argp2 ;
43226
43227   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
43228   argp2 = (Dali::Actor *)jarg2;
43229   if (!argp2) {
43230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
43231     return ;
43232   }
43233   arg2 = *argp2;
43234   arg3 = (unsigned int)jarg3;
43235   {
43236     try {
43237       (arg1)->ApplyToPage(arg2,arg3);
43238     } CALL_CATCH_EXCEPTION();
43239   }
43240
43241 }
43242
43243
43244 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
43245   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
43246
43247   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
43248   {
43249     try {
43250       delete arg1;
43251     } CALL_CATCH_EXCEPTION();
43252   }
43253
43254 }
43255
43256
43257 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
43258   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
43259   Dali::Toolkit::ClampState arg2 ;
43260
43261   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
43262   arg2 = (Dali::Toolkit::ClampState)jarg2;
43263   if (arg1) (arg1)->x = arg2;
43264 }
43265
43266
43267 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
43268   int jresult ;
43269   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
43270   Dali::Toolkit::ClampState result;
43271
43272   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
43273   result = (Dali::Toolkit::ClampState) ((arg1)->x);
43274   jresult = (int)result;
43275   return jresult;
43276 }
43277
43278
43279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
43280   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
43281   Dali::Toolkit::ClampState arg2 ;
43282
43283   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
43284   arg2 = (Dali::Toolkit::ClampState)jarg2;
43285   if (arg1) (arg1)->y = arg2;
43286 }
43287
43288
43289 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
43290   int jresult ;
43291   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
43292   Dali::Toolkit::ClampState result;
43293
43294   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
43295   result = (Dali::Toolkit::ClampState) ((arg1)->y);
43296   jresult = (int)result;
43297   return jresult;
43298 }
43299
43300
43301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
43302   void * jresult ;
43303   Dali::Toolkit::ClampState2D *result = 0 ;
43304
43305   {
43306     try {
43307       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
43308     } CALL_CATCH_EXCEPTION(0);
43309   }
43310
43311   jresult = (void *)result;
43312   return jresult;
43313 }
43314
43315
43316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
43317   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
43318
43319   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
43320   {
43321     try {
43322       delete arg1;
43323     } CALL_CATCH_EXCEPTION();
43324   }
43325
43326 }
43327
43328
43329 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
43330   void * jresult ;
43331   float arg1 ;
43332   float arg2 ;
43333   bool arg3 ;
43334   Dali::Toolkit::RulerDomain *result = 0 ;
43335
43336   arg1 = (float)jarg1;
43337   arg2 = (float)jarg2;
43338   arg3 = jarg3 ? true : false;
43339   {
43340     try {
43341       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
43342     } CALL_CATCH_EXCEPTION(0);
43343   }
43344
43345   jresult = (void *)result;
43346   return jresult;
43347 }
43348
43349
43350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
43351   void * jresult ;
43352   float arg1 ;
43353   float arg2 ;
43354   Dali::Toolkit::RulerDomain *result = 0 ;
43355
43356   arg1 = (float)jarg1;
43357   arg2 = (float)jarg2;
43358   {
43359     try {
43360       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
43361     } CALL_CATCH_EXCEPTION(0);
43362   }
43363
43364   jresult = (void *)result;
43365   return jresult;
43366 }
43367
43368
43369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
43370   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
43371   float arg2 ;
43372
43373   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
43374   arg2 = (float)jarg2;
43375   if (arg1) (arg1)->min = arg2;
43376 }
43377
43378
43379 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
43380   float jresult ;
43381   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
43382   float result;
43383
43384   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
43385   result = (float) ((arg1)->min);
43386   jresult = result;
43387   return jresult;
43388 }
43389
43390
43391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
43392   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
43393   float arg2 ;
43394
43395   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
43396   arg2 = (float)jarg2;
43397   if (arg1) (arg1)->max = arg2;
43398 }
43399
43400
43401 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
43402   float jresult ;
43403   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
43404   float result;
43405
43406   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
43407   result = (float) ((arg1)->max);
43408   jresult = result;
43409   return jresult;
43410 }
43411
43412
43413 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
43414   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
43415   bool arg2 ;
43416
43417   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
43418   arg2 = jarg2 ? true : false;
43419   if (arg1) (arg1)->enabled = arg2;
43420 }
43421
43422
43423 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
43424   unsigned int jresult ;
43425   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
43426   bool result;
43427
43428   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
43429   result = (bool) ((arg1)->enabled);
43430   jresult = result;
43431   return jresult;
43432 }
43433
43434
43435 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
43436   float jresult ;
43437   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
43438   float arg2 ;
43439   float arg3 ;
43440   float arg4 ;
43441   float result;
43442
43443   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
43444   arg2 = (float)jarg2;
43445   arg3 = (float)jarg3;
43446   arg4 = (float)jarg4;
43447   {
43448     try {
43449       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
43450     } CALL_CATCH_EXCEPTION(0);
43451   }
43452
43453   jresult = result;
43454   return jresult;
43455 }
43456
43457
43458 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
43459   float jresult ;
43460   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
43461   float arg2 ;
43462   float arg3 ;
43463   float result;
43464
43465   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
43466   arg2 = (float)jarg2;
43467   arg3 = (float)jarg3;
43468   {
43469     try {
43470       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
43471     } CALL_CATCH_EXCEPTION(0);
43472   }
43473
43474   jresult = result;
43475   return jresult;
43476 }
43477
43478
43479 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
43480   float jresult ;
43481   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
43482   float arg2 ;
43483   float result;
43484
43485   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
43486   arg2 = (float)jarg2;
43487   {
43488     try {
43489       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
43490     } CALL_CATCH_EXCEPTION(0);
43491   }
43492
43493   jresult = result;
43494   return jresult;
43495 }
43496
43497
43498 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
43499   float jresult ;
43500   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
43501   float arg2 ;
43502   float arg3 ;
43503   float arg4 ;
43504   Dali::Toolkit::ClampState *arg5 = 0 ;
43505   float result;
43506
43507   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
43508   arg2 = (float)jarg2;
43509   arg3 = (float)jarg3;
43510   arg4 = (float)jarg4;
43511   arg5 = (Dali::Toolkit::ClampState *)jarg5;
43512   if (!arg5) {
43513     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
43514     return 0;
43515   }
43516   {
43517     try {
43518       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
43519     } CALL_CATCH_EXCEPTION(0);
43520   }
43521
43522   jresult = result;
43523   return jresult;
43524 }
43525
43526
43527 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
43528   float jresult ;
43529   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
43530   float result;
43531
43532   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
43533   {
43534     try {
43535       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
43536     } CALL_CATCH_EXCEPTION(0);
43537   }
43538
43539   jresult = result;
43540   return jresult;
43541 }
43542
43543
43544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
43545   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
43546
43547   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
43548   {
43549     try {
43550       delete arg1;
43551     } CALL_CATCH_EXCEPTION();
43552   }
43553
43554 }
43555
43556
43557 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
43558   float jresult ;
43559   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43560   float arg2 ;
43561   float arg3 ;
43562   float result;
43563
43564   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43565   arg2 = (float)jarg2;
43566   arg3 = (float)jarg3;
43567   {
43568     try {
43569       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
43570     } CALL_CATCH_EXCEPTION(0);
43571   }
43572
43573   jresult = result;
43574   return jresult;
43575 }
43576
43577
43578 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
43579   float jresult ;
43580   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43581   float arg2 ;
43582   float result;
43583
43584   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43585   arg2 = (float)jarg2;
43586   {
43587     try {
43588       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
43589     } CALL_CATCH_EXCEPTION(0);
43590   }
43591
43592   jresult = result;
43593   return jresult;
43594 }
43595
43596
43597 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
43598   float jresult ;
43599   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43600   unsigned int arg2 ;
43601   unsigned int *arg3 = 0 ;
43602   bool arg4 ;
43603   float result;
43604
43605   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43606   arg2 = (unsigned int)jarg2;
43607   arg3 = (unsigned int *)jarg3;
43608   arg4 = jarg4 ? true : false;
43609   {
43610     try {
43611       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
43612     } CALL_CATCH_EXCEPTION(0);
43613   }
43614
43615   jresult = result;
43616   return jresult;
43617 }
43618
43619
43620 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
43621   unsigned int jresult ;
43622   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43623   float arg2 ;
43624   bool arg3 ;
43625   unsigned int result;
43626
43627   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43628   arg2 = (float)jarg2;
43629   arg3 = jarg3 ? true : false;
43630   {
43631     try {
43632       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
43633     } CALL_CATCH_EXCEPTION(0);
43634   }
43635
43636   jresult = result;
43637   return jresult;
43638 }
43639
43640
43641 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
43642   unsigned int jresult ;
43643   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43644   unsigned int result;
43645
43646   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43647   {
43648     try {
43649       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
43650     } CALL_CATCH_EXCEPTION(0);
43651   }
43652
43653   jresult = result;
43654   return jresult;
43655 }
43656
43657
43658 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
43659   int jresult ;
43660   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43661   Dali::Toolkit::Ruler::RulerType result;
43662
43663   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43664   {
43665     try {
43666       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
43667     } CALL_CATCH_EXCEPTION(0);
43668   }
43669
43670   jresult = (int)result;
43671   return jresult;
43672 }
43673
43674
43675 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
43676   unsigned int jresult ;
43677   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43678   bool result;
43679
43680   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43681   {
43682     try {
43683       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
43684     } CALL_CATCH_EXCEPTION(0);
43685   }
43686
43687   jresult = result;
43688   return jresult;
43689 }
43690
43691
43692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
43693   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43694
43695   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43696   {
43697     try {
43698       (arg1)->Enable();
43699     } CALL_CATCH_EXCEPTION();
43700   }
43701
43702 }
43703
43704
43705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
43706   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43707
43708   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43709   {
43710     try {
43711       (arg1)->Disable();
43712     } CALL_CATCH_EXCEPTION();
43713   }
43714
43715 }
43716
43717
43718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
43719   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43720   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
43721   Dali::Toolkit::RulerDomain *argp2 ;
43722
43723   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43724   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
43725   if (!argp2) {
43726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
43727     return ;
43728   }
43729   arg2 = *argp2;
43730   {
43731     try {
43732       (arg1)->SetDomain(arg2);
43733     } CALL_CATCH_EXCEPTION();
43734   }
43735
43736 }
43737
43738
43739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
43740   void * jresult ;
43741   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43742   Dali::Toolkit::RulerDomain *result = 0 ;
43743
43744   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43745   {
43746     try {
43747       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
43748     } CALL_CATCH_EXCEPTION(0);
43749   }
43750
43751   jresult = (void *)result;
43752   return jresult;
43753 }
43754
43755
43756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
43757   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43758
43759   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43760   {
43761     try {
43762       (arg1)->DisableDomain();
43763     } CALL_CATCH_EXCEPTION();
43764   }
43765
43766 }
43767
43768
43769 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
43770   float jresult ;
43771   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43772   float arg2 ;
43773   float arg3 ;
43774   float arg4 ;
43775   float result;
43776
43777   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43778   arg2 = (float)jarg2;
43779   arg3 = (float)jarg3;
43780   arg4 = (float)jarg4;
43781   {
43782     try {
43783       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
43784     } CALL_CATCH_EXCEPTION(0);
43785   }
43786
43787   jresult = result;
43788   return jresult;
43789 }
43790
43791
43792 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
43793   float jresult ;
43794   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43795   float arg2 ;
43796   float arg3 ;
43797   float result;
43798
43799   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43800   arg2 = (float)jarg2;
43801   arg3 = (float)jarg3;
43802   {
43803     try {
43804       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
43805     } CALL_CATCH_EXCEPTION(0);
43806   }
43807
43808   jresult = result;
43809   return jresult;
43810 }
43811
43812
43813 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
43814   float jresult ;
43815   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43816   float arg2 ;
43817   float result;
43818
43819   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43820   arg2 = (float)jarg2;
43821   {
43822     try {
43823       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
43824     } CALL_CATCH_EXCEPTION(0);
43825   }
43826
43827   jresult = result;
43828   return jresult;
43829 }
43830
43831
43832 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
43833   float jresult ;
43834   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43835   float arg2 ;
43836   float arg3 ;
43837   float arg4 ;
43838   Dali::Toolkit::ClampState *arg5 = 0 ;
43839   float result;
43840
43841   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43842   arg2 = (float)jarg2;
43843   arg3 = (float)jarg3;
43844   arg4 = (float)jarg4;
43845   arg5 = (Dali::Toolkit::ClampState *)jarg5;
43846   if (!arg5) {
43847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
43848     return 0;
43849   }
43850   {
43851     try {
43852       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
43853     } CALL_CATCH_EXCEPTION(0);
43854   }
43855
43856   jresult = result;
43857   return jresult;
43858 }
43859
43860
43861 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
43862   float jresult ;
43863   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43864   float arg2 ;
43865   float arg3 ;
43866   float arg4 ;
43867   float arg5 ;
43868   float result;
43869
43870   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43871   arg2 = (float)jarg2;
43872   arg3 = (float)jarg3;
43873   arg4 = (float)jarg4;
43874   arg5 = (float)jarg5;
43875   {
43876     try {
43877       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
43878     } CALL_CATCH_EXCEPTION(0);
43879   }
43880
43881   jresult = result;
43882   return jresult;
43883 }
43884
43885
43886 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
43887   float jresult ;
43888   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43889   float arg2 ;
43890   float arg3 ;
43891   float arg4 ;
43892   float result;
43893
43894   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43895   arg2 = (float)jarg2;
43896   arg3 = (float)jarg3;
43897   arg4 = (float)jarg4;
43898   {
43899     try {
43900       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
43901     } CALL_CATCH_EXCEPTION(0);
43902   }
43903
43904   jresult = result;
43905   return jresult;
43906 }
43907
43908
43909 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
43910   float jresult ;
43911   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43912   float arg2 ;
43913   float arg3 ;
43914   float result;
43915
43916   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43917   arg2 = (float)jarg2;
43918   arg3 = (float)jarg3;
43919   {
43920     try {
43921       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
43922     } CALL_CATCH_EXCEPTION(0);
43923   }
43924
43925   jresult = result;
43926   return jresult;
43927 }
43928
43929
43930 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
43931   float jresult ;
43932   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43933   float arg2 ;
43934   float result;
43935
43936   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43937   arg2 = (float)jarg2;
43938   {
43939     try {
43940       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
43941     } CALL_CATCH_EXCEPTION(0);
43942   }
43943
43944   jresult = result;
43945   return jresult;
43946 }
43947
43948
43949 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
43950   float jresult ;
43951   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43952   float arg2 ;
43953   float arg3 ;
43954   float arg4 ;
43955   float arg5 ;
43956   Dali::Toolkit::ClampState *arg6 = 0 ;
43957   float result;
43958
43959   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43960   arg2 = (float)jarg2;
43961   arg3 = (float)jarg3;
43962   arg4 = (float)jarg4;
43963   arg5 = (float)jarg5;
43964   arg6 = (Dali::Toolkit::ClampState *)jarg6;
43965   if (!arg6) {
43966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
43967     return 0;
43968   }
43969   {
43970     try {
43971       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
43972     } CALL_CATCH_EXCEPTION(0);
43973   }
43974
43975   jresult = result;
43976   return jresult;
43977 }
43978
43979
43980 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
43981   void * jresult ;
43982   Dali::Toolkit::DefaultRuler *result = 0 ;
43983
43984   {
43985     try {
43986       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
43987     } CALL_CATCH_EXCEPTION(0);
43988   }
43989
43990   jresult = (void *)result;
43991   return jresult;
43992 }
43993
43994
43995 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
43996   float jresult ;
43997   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
43998   float arg2 ;
43999   float arg3 ;
44000   float result;
44001
44002   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
44003   arg2 = (float)jarg2;
44004   arg3 = (float)jarg3;
44005   {
44006     try {
44007       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
44008     } CALL_CATCH_EXCEPTION(0);
44009   }
44010
44011   jresult = result;
44012   return jresult;
44013 }
44014
44015
44016 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
44017   float jresult ;
44018   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
44019   unsigned int arg2 ;
44020   unsigned int *arg3 = 0 ;
44021   bool arg4 ;
44022   float result;
44023
44024   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
44025   arg2 = (unsigned int)jarg2;
44026   arg3 = (unsigned int *)jarg3;
44027   arg4 = jarg4 ? true : false;
44028   {
44029     try {
44030       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
44031     } CALL_CATCH_EXCEPTION(0);
44032   }
44033
44034   jresult = result;
44035   return jresult;
44036 }
44037
44038
44039 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
44040   unsigned int jresult ;
44041   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
44042   float arg2 ;
44043   bool arg3 ;
44044   unsigned int result;
44045
44046   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
44047   arg2 = (float)jarg2;
44048   arg3 = jarg3 ? true : false;
44049   {
44050     try {
44051       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
44052     } CALL_CATCH_EXCEPTION(0);
44053   }
44054
44055   jresult = result;
44056   return jresult;
44057 }
44058
44059
44060 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
44061   unsigned int jresult ;
44062   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
44063   unsigned int result;
44064
44065   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
44066   {
44067     try {
44068       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
44069     } CALL_CATCH_EXCEPTION(0);
44070   }
44071
44072   jresult = result;
44073   return jresult;
44074 }
44075
44076
44077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
44078   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
44079
44080   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
44081   {
44082     try {
44083       delete arg1;
44084     } CALL_CATCH_EXCEPTION();
44085   }
44086
44087 }
44088
44089
44090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
44091   void * jresult ;
44092   float arg1 ;
44093   Dali::Toolkit::FixedRuler *result = 0 ;
44094
44095   arg1 = (float)jarg1;
44096   {
44097     try {
44098       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
44099     } CALL_CATCH_EXCEPTION(0);
44100   }
44101
44102   jresult = (void *)result;
44103   return jresult;
44104 }
44105
44106
44107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
44108   void * jresult ;
44109   Dali::Toolkit::FixedRuler *result = 0 ;
44110
44111   {
44112     try {
44113       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
44114     } CALL_CATCH_EXCEPTION(0);
44115   }
44116
44117   jresult = (void *)result;
44118   return jresult;
44119 }
44120
44121
44122 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
44123   float jresult ;
44124   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
44125   float arg2 ;
44126   float arg3 ;
44127   float result;
44128
44129   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
44130   arg2 = (float)jarg2;
44131   arg3 = (float)jarg3;
44132   {
44133     try {
44134       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
44135     } CALL_CATCH_EXCEPTION(0);
44136   }
44137
44138   jresult = result;
44139   return jresult;
44140 }
44141
44142
44143 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
44144   float jresult ;
44145   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
44146   unsigned int arg2 ;
44147   unsigned int *arg3 = 0 ;
44148   bool arg4 ;
44149   float result;
44150
44151   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
44152   arg2 = (unsigned int)jarg2;
44153   arg3 = (unsigned int *)jarg3;
44154   arg4 = jarg4 ? true : false;
44155   {
44156     try {
44157       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
44158     } CALL_CATCH_EXCEPTION(0);
44159   }
44160
44161   jresult = result;
44162   return jresult;
44163 }
44164
44165
44166 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
44167   unsigned int jresult ;
44168   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
44169   float arg2 ;
44170   bool arg3 ;
44171   unsigned int result;
44172
44173   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
44174   arg2 = (float)jarg2;
44175   arg3 = jarg3 ? true : false;
44176   {
44177     try {
44178       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
44179     } CALL_CATCH_EXCEPTION(0);
44180   }
44181
44182   jresult = result;
44183   return jresult;
44184 }
44185
44186
44187 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
44188   unsigned int jresult ;
44189   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
44190   unsigned int result;
44191
44192   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
44193   {
44194     try {
44195       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
44196     } CALL_CATCH_EXCEPTION(0);
44197   }
44198
44199   jresult = result;
44200   return jresult;
44201 }
44202
44203
44204 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
44205   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
44206
44207   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
44208   {
44209     try {
44210       delete arg1;
44211     } CALL_CATCH_EXCEPTION();
44212   }
44213
44214 }
44215
44216
44217 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
44218   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
44219   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
44220
44221   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
44222   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
44223   if (arg1) (arg1)->scale = *arg2;
44224 }
44225
44226
44227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
44228   void * jresult ;
44229   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
44230   Dali::Toolkit::ClampState2D *result = 0 ;
44231
44232   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
44233   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
44234   jresult = (void *)result;
44235   return jresult;
44236 }
44237
44238
44239 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
44240   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
44241   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
44242
44243   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
44244   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
44245   if (arg1) (arg1)->position = *arg2;
44246 }
44247
44248
44249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
44250   void * jresult ;
44251   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
44252   Dali::Toolkit::ClampState2D *result = 0 ;
44253
44254   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
44255   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
44256   jresult = (void *)result;
44257   return jresult;
44258 }
44259
44260
44261 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
44262   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
44263   Dali::Toolkit::ClampState arg2 ;
44264
44265   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
44266   arg2 = (Dali::Toolkit::ClampState)jarg2;
44267   if (arg1) (arg1)->rotation = arg2;
44268 }
44269
44270
44271 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
44272   int jresult ;
44273   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
44274   Dali::Toolkit::ClampState result;
44275
44276   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
44277   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
44278   jresult = (int)result;
44279   return jresult;
44280 }
44281
44282
44283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
44284   void * jresult ;
44285   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
44286
44287   {
44288     try {
44289       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
44290     } CALL_CATCH_EXCEPTION(0);
44291   }
44292
44293   jresult = (void *)result;
44294   return jresult;
44295 }
44296
44297
44298 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
44299   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
44300
44301   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
44302   {
44303     try {
44304       delete arg1;
44305     } CALL_CATCH_EXCEPTION();
44306   }
44307
44308 }
44309
44310
44311 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
44312   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
44313   Dali::Toolkit::SnapType arg2 ;
44314
44315   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
44316   arg2 = (Dali::Toolkit::SnapType)jarg2;
44317   if (arg1) (arg1)->type = arg2;
44318 }
44319
44320
44321 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
44322   int jresult ;
44323   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
44324   Dali::Toolkit::SnapType result;
44325
44326   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
44327   result = (Dali::Toolkit::SnapType) ((arg1)->type);
44328   jresult = (int)result;
44329   return jresult;
44330 }
44331
44332
44333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
44334   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
44335   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
44336
44337   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
44338   arg2 = (Dali::Vector2 *)jarg2;
44339   if (arg1) (arg1)->position = *arg2;
44340 }
44341
44342
44343 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
44344   void * jresult ;
44345   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
44346   Dali::Vector2 *result = 0 ;
44347
44348   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
44349   result = (Dali::Vector2 *)& ((arg1)->position);
44350   jresult = (void *)result;
44351   return jresult;
44352 }
44353
44354
44355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
44356   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
44357   float arg2 ;
44358
44359   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
44360   arg2 = (float)jarg2;
44361   if (arg1) (arg1)->duration = arg2;
44362 }
44363
44364
44365 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
44366   float jresult ;
44367   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
44368   float result;
44369
44370   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
44371   result = (float) ((arg1)->duration);
44372   jresult = result;
44373   return jresult;
44374 }
44375
44376
44377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
44378   void * jresult ;
44379   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
44380
44381   {
44382     try {
44383       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
44384     } CALL_CATCH_EXCEPTION(0);
44385   }
44386
44387   jresult = (void *)result;
44388   return jresult;
44389 }
44390
44391
44392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
44393   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
44394
44395   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
44396   {
44397     try {
44398       delete arg1;
44399     } CALL_CATCH_EXCEPTION();
44400   }
44401
44402 }
44403
44404
44405 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
44406   int jresult ;
44407   int result;
44408
44409   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
44410   jresult = (int)result;
44411   return jresult;
44412 }
44413
44414
44415 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
44416   int jresult ;
44417   int result;
44418
44419   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
44420   jresult = (int)result;
44421   return jresult;
44422 }
44423
44424
44425 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
44426   int jresult ;
44427   int result;
44428
44429   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
44430   jresult = (int)result;
44431   return jresult;
44432 }
44433
44434
44435 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
44436   int jresult ;
44437   int result;
44438
44439   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
44440   jresult = (int)result;
44441   return jresult;
44442 }
44443
44444
44445 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_MODE_get() {
44446   int jresult ;
44447   int result;
44448
44449   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_MODE;
44450   jresult = (int)result;
44451   return jresult;
44452 }
44453
44454 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
44455   int jresult ;
44456   int result;
44457
44458   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
44459   jresult = (int)result;
44460   return jresult;
44461 }
44462
44463
44464 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
44465   int jresult ;
44466   int result;
44467
44468   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
44469   jresult = (int)result;
44470   return jresult;
44471 }
44472
44473
44474 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
44475   int jresult ;
44476   int result;
44477
44478   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
44479   jresult = (int)result;
44480   return jresult;
44481 }
44482
44483
44484 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
44485   int jresult ;
44486   int result;
44487
44488   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
44489   jresult = (int)result;
44490   return jresult;
44491 }
44492
44493
44494 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
44495   int jresult ;
44496   int result;
44497
44498   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
44499   jresult = (int)result;
44500   return jresult;
44501 }
44502
44503
44504 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
44505   int jresult ;
44506   int result;
44507
44508   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
44509   jresult = (int)result;
44510   return jresult;
44511 }
44512
44513
44514 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
44515   int jresult ;
44516   int result;
44517
44518   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
44519   jresult = (int)result;
44520   return jresult;
44521 }
44522
44523
44524 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
44525   int jresult ;
44526   int result;
44527
44528   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
44529   jresult = (int)result;
44530   return jresult;
44531 }
44532
44533
44534 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
44535   int jresult ;
44536   int result;
44537
44538   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
44539   jresult = (int)result;
44540   return jresult;
44541 }
44542
44543
44544 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
44545   int jresult ;
44546   int result;
44547
44548   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
44549   jresult = (int)result;
44550   return jresult;
44551 }
44552
44553
44554 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
44555   int jresult ;
44556   int result;
44557
44558   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
44559   jresult = (int)result;
44560   return jresult;
44561 }
44562
44563
44564 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
44565   int jresult ;
44566   int result;
44567
44568   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
44569   jresult = (int)result;
44570   return jresult;
44571 }
44572
44573
44574 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
44575   int jresult ;
44576   int result;
44577
44578   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
44579   jresult = (int)result;
44580   return jresult;
44581 }
44582
44583
44584 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
44585   int jresult ;
44586   int result;
44587
44588   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
44589   jresult = (int)result;
44590   return jresult;
44591 }
44592
44593
44594 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
44595   int jresult ;
44596   int result;
44597
44598   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
44599   jresult = (int)result;
44600   return jresult;
44601 }
44602
44603
44604 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
44605   int jresult ;
44606   int result;
44607
44608   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
44609   jresult = (int)result;
44610   return jresult;
44611 }
44612
44613
44614 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
44615   int jresult ;
44616   int result;
44617
44618   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
44619   jresult = (int)result;
44620   return jresult;
44621 }
44622
44623
44624 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
44625   int jresult ;
44626   int result;
44627
44628   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
44629   jresult = (int)result;
44630   return jresult;
44631 }
44632
44633
44634 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
44635   int jresult ;
44636   int result;
44637
44638   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
44639   jresult = (int)result;
44640   return jresult;
44641 }
44642
44643
44644 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
44645   int jresult ;
44646   int result;
44647
44648   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
44649   jresult = (int)result;
44650   return jresult;
44651 }
44652
44653
44654 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
44655   int jresult ;
44656   int result;
44657
44658   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
44659   jresult = (int)result;
44660   return jresult;
44661 }
44662
44663
44664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
44665   void * jresult ;
44666   Dali::Toolkit::ScrollView::Property *result = 0 ;
44667
44668   {
44669     try {
44670       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
44671     } CALL_CATCH_EXCEPTION(0);
44672   }
44673
44674   jresult = (void *)result;
44675   return jresult;
44676 }
44677
44678
44679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
44680   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
44681
44682   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
44683   {
44684     try {
44685       delete arg1;
44686     } CALL_CATCH_EXCEPTION();
44687   }
44688
44689 }
44690
44691
44692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
44693   void * jresult ;
44694   Dali::Toolkit::ScrollView *result = 0 ;
44695
44696   {
44697     try {
44698       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
44699     } CALL_CATCH_EXCEPTION(0);
44700   }
44701
44702   jresult = (void *)result;
44703   return jresult;
44704 }
44705
44706
44707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
44708   void * jresult ;
44709   Dali::Toolkit::ScrollView *arg1 = 0 ;
44710   Dali::Toolkit::ScrollView *result = 0 ;
44711
44712   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44713   if (!arg1) {
44714     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
44715     return 0;
44716   }
44717   {
44718     try {
44719       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
44720     } CALL_CATCH_EXCEPTION(0);
44721   }
44722
44723   jresult = (void *)result;
44724   return jresult;
44725 }
44726
44727
44728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
44729   void * jresult ;
44730   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44731   Dali::Toolkit::ScrollView *arg2 = 0 ;
44732   Dali::Toolkit::ScrollView *result = 0 ;
44733
44734   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44735   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
44736   if (!arg2) {
44737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
44738     return 0;
44739   }
44740   {
44741     try {
44742       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
44743     } CALL_CATCH_EXCEPTION(0);
44744   }
44745
44746   jresult = (void *)result;
44747   return jresult;
44748 }
44749
44750
44751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
44752   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44753
44754   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44755   {
44756     try {
44757       delete arg1;
44758     } CALL_CATCH_EXCEPTION();
44759   }
44760
44761 }
44762
44763
44764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
44765   void * jresult ;
44766   Dali::Toolkit::ScrollView result;
44767
44768   {
44769     try {
44770       result = Dali::Toolkit::ScrollView::New();
44771     } CALL_CATCH_EXCEPTION(0);
44772   }
44773
44774   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
44775   return jresult;
44776 }
44777
44778
44779 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
44780   void * jresult ;
44781   Dali::BaseHandle arg1 ;
44782   Dali::BaseHandle *argp1 ;
44783   Dali::Toolkit::ScrollView result;
44784
44785   argp1 = (Dali::BaseHandle *)jarg1;
44786   if (!argp1) {
44787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44788     return 0;
44789   }
44790   arg1 = *argp1;
44791   {
44792     try {
44793       result = Dali::Toolkit::ScrollView::DownCast(arg1);
44794     } CALL_CATCH_EXCEPTION(0);
44795   }
44796
44797   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
44798   return jresult;
44799 }
44800
44801
44802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
44803   void * jresult ;
44804   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44805   Dali::AlphaFunction result;
44806
44807   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44808   {
44809     try {
44810       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
44811     } CALL_CATCH_EXCEPTION(0);
44812   }
44813
44814   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
44815   return jresult;
44816 }
44817
44818
44819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
44820   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44821   Dali::AlphaFunction arg2 ;
44822   Dali::AlphaFunction *argp2 ;
44823
44824   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44825   argp2 = (Dali::AlphaFunction *)jarg2;
44826   if (!argp2) {
44827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
44828     return ;
44829   }
44830   arg2 = *argp2;
44831   {
44832     try {
44833       (arg1)->SetScrollSnapAlphaFunction(arg2);
44834     } CALL_CATCH_EXCEPTION();
44835   }
44836
44837 }
44838
44839
44840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
44841   void * jresult ;
44842   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44843   Dali::AlphaFunction result;
44844
44845   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44846   {
44847     try {
44848       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
44849     } CALL_CATCH_EXCEPTION(0);
44850   }
44851
44852   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
44853   return jresult;
44854 }
44855
44856
44857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
44858   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44859   Dali::AlphaFunction arg2 ;
44860   Dali::AlphaFunction *argp2 ;
44861
44862   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44863   argp2 = (Dali::AlphaFunction *)jarg2;
44864   if (!argp2) {
44865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
44866     return ;
44867   }
44868   arg2 = *argp2;
44869   {
44870     try {
44871       (arg1)->SetScrollFlickAlphaFunction(arg2);
44872     } CALL_CATCH_EXCEPTION();
44873   }
44874
44875 }
44876
44877
44878 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
44879   float jresult ;
44880   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44881   float result;
44882
44883   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44884   {
44885     try {
44886       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
44887     } CALL_CATCH_EXCEPTION(0);
44888   }
44889
44890   jresult = result;
44891   return jresult;
44892 }
44893
44894
44895 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
44896   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44897   float arg2 ;
44898
44899   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44900   arg2 = (float)jarg2;
44901   {
44902     try {
44903       (arg1)->SetScrollSnapDuration(arg2);
44904     } CALL_CATCH_EXCEPTION();
44905   }
44906
44907 }
44908
44909
44910 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
44911   float jresult ;
44912   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44913   float result;
44914
44915   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44916   {
44917     try {
44918       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
44919     } CALL_CATCH_EXCEPTION(0);
44920   }
44921
44922   jresult = result;
44923   return jresult;
44924 }
44925
44926
44927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
44928   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44929   float arg2 ;
44930
44931   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44932   arg2 = (float)jarg2;
44933   {
44934     try {
44935       (arg1)->SetScrollFlickDuration(arg2);
44936     } CALL_CATCH_EXCEPTION();
44937   }
44938
44939 }
44940
44941
44942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
44943   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44944   Dali::Toolkit::RulerPtr arg2 ;
44945   Dali::Toolkit::RulerPtr *argp2 ;
44946
44947   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44948   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
44949   if (!argp2) {
44950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
44951     return ;
44952   }
44953   arg2 = *argp2;
44954   {
44955     try {
44956       (arg1)->SetRulerX(arg2);
44957     } CALL_CATCH_EXCEPTION();
44958   }
44959
44960 }
44961
44962
44963 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
44964   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44965   Dali::Toolkit::RulerPtr arg2 ;
44966   Dali::Toolkit::RulerPtr *argp2 ;
44967
44968   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44969   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
44970   if (!argp2) {
44971     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
44972     return ;
44973   }
44974   arg2 = *argp2;
44975   {
44976     try {
44977       (arg1)->SetRulerY(arg2);
44978     } CALL_CATCH_EXCEPTION();
44979   }
44980
44981 }
44982
44983
44984 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
44985   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44986   bool arg2 ;
44987
44988   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44989   arg2 = jarg2 ? true : false;
44990   {
44991     try {
44992       (arg1)->SetScrollSensitive(arg2);
44993     } CALL_CATCH_EXCEPTION();
44994   }
44995
44996 }
44997
44998
44999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
45000   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45001   float arg2 ;
45002   float arg3 ;
45003
45004   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45005   arg2 = (float)jarg2;
45006   arg3 = (float)jarg3;
45007   {
45008     try {
45009       (arg1)->SetMaxOvershoot(arg2,arg3);
45010     } CALL_CATCH_EXCEPTION();
45011   }
45012
45013 }
45014
45015
45016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
45017   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45018   Dali::AlphaFunction arg2 ;
45019   Dali::AlphaFunction *argp2 ;
45020
45021   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45022   argp2 = (Dali::AlphaFunction *)jarg2;
45023   if (!argp2) {
45024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
45025     return ;
45026   }
45027   arg2 = *argp2;
45028   {
45029     try {
45030       (arg1)->SetSnapOvershootAlphaFunction(arg2);
45031     } CALL_CATCH_EXCEPTION();
45032   }
45033
45034 }
45035
45036
45037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
45038   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45039   float arg2 ;
45040
45041   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45042   arg2 = (float)jarg2;
45043   {
45044     try {
45045       (arg1)->SetSnapOvershootDuration(arg2);
45046     } CALL_CATCH_EXCEPTION();
45047   }
45048
45049 }
45050
45051
45052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
45053   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45054   bool arg2 ;
45055
45056   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45057   arg2 = jarg2 ? true : false;
45058   {
45059     try {
45060       (arg1)->SetActorAutoSnap(arg2);
45061     } CALL_CATCH_EXCEPTION();
45062   }
45063
45064 }
45065
45066
45067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
45068   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45069   bool arg2 ;
45070
45071   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45072   arg2 = jarg2 ? true : false;
45073   {
45074     try {
45075       (arg1)->SetWrapMode(arg2);
45076     } CALL_CATCH_EXCEPTION();
45077   }
45078
45079 }
45080
45081
45082 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
45083   int jresult ;
45084   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45085   int result;
45086
45087   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45088   {
45089     try {
45090       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
45091     } CALL_CATCH_EXCEPTION(0);
45092   }
45093
45094   jresult = result;
45095   return jresult;
45096 }
45097
45098
45099 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
45100   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45101   int arg2 ;
45102
45103   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45104   arg2 = (int)jarg2;
45105   {
45106     try {
45107       (arg1)->SetScrollUpdateDistance(arg2);
45108     } CALL_CATCH_EXCEPTION();
45109   }
45110
45111 }
45112
45113
45114 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
45115   unsigned int jresult ;
45116   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45117   bool result;
45118
45119   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45120   {
45121     try {
45122       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
45123     } CALL_CATCH_EXCEPTION(0);
45124   }
45125
45126   jresult = result;
45127   return jresult;
45128 }
45129
45130
45131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
45132   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45133   bool arg2 ;
45134
45135   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45136   arg2 = jarg2 ? true : false;
45137   {
45138     try {
45139       (arg1)->SetAxisAutoLock(arg2);
45140     } CALL_CATCH_EXCEPTION();
45141   }
45142
45143 }
45144
45145
45146 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
45147   float jresult ;
45148   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45149   float result;
45150
45151   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45152   {
45153     try {
45154       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
45155     } CALL_CATCH_EXCEPTION(0);
45156   }
45157
45158   jresult = result;
45159   return jresult;
45160 }
45161
45162
45163 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
45164   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45165   float arg2 ;
45166
45167   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45168   arg2 = (float)jarg2;
45169   {
45170     try {
45171       (arg1)->SetAxisAutoLockGradient(arg2);
45172     } CALL_CATCH_EXCEPTION();
45173   }
45174
45175 }
45176
45177
45178 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
45179   float jresult ;
45180   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45181   float result;
45182
45183   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45184   {
45185     try {
45186       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
45187     } CALL_CATCH_EXCEPTION(0);
45188   }
45189
45190   jresult = result;
45191   return jresult;
45192 }
45193
45194
45195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
45196   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45197   float arg2 ;
45198
45199   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45200   arg2 = (float)jarg2;
45201   {
45202     try {
45203       (arg1)->SetFrictionCoefficient(arg2);
45204     } CALL_CATCH_EXCEPTION();
45205   }
45206
45207 }
45208
45209
45210 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
45211   float jresult ;
45212   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45213   float result;
45214
45215   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45216   {
45217     try {
45218       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
45219     } CALL_CATCH_EXCEPTION(0);
45220   }
45221
45222   jresult = result;
45223   return jresult;
45224 }
45225
45226
45227 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
45228   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45229   float arg2 ;
45230
45231   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45232   arg2 = (float)jarg2;
45233   {
45234     try {
45235       (arg1)->SetFlickSpeedCoefficient(arg2);
45236     } CALL_CATCH_EXCEPTION();
45237   }
45238
45239 }
45240
45241
45242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
45243   void * jresult ;
45244   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45245   Dali::Vector2 result;
45246
45247   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45248   {
45249     try {
45250       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
45251     } CALL_CATCH_EXCEPTION(0);
45252   }
45253
45254   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
45255   return jresult;
45256 }
45257
45258
45259 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
45260   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45261   Dali::Vector2 *arg2 = 0 ;
45262
45263   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45264   arg2 = (Dali::Vector2 *)jarg2;
45265   if (!arg2) {
45266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
45267     return ;
45268   }
45269   {
45270     try {
45271       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
45272     } CALL_CATCH_EXCEPTION();
45273   }
45274
45275 }
45276
45277
45278 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
45279   float jresult ;
45280   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45281   float result;
45282
45283   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45284   {
45285     try {
45286       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
45287     } CALL_CATCH_EXCEPTION(0);
45288   }
45289
45290   jresult = result;
45291   return jresult;
45292 }
45293
45294
45295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
45296   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45297   float arg2 ;
45298
45299   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45300   arg2 = (float)jarg2;
45301   {
45302     try {
45303       (arg1)->SetMinimumSpeedForFlick(arg2);
45304     } CALL_CATCH_EXCEPTION();
45305   }
45306
45307 }
45308
45309
45310 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
45311   float jresult ;
45312   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45313   float result;
45314
45315   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45316   {
45317     try {
45318       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
45319     } CALL_CATCH_EXCEPTION(0);
45320   }
45321
45322   jresult = result;
45323   return jresult;
45324 }
45325
45326
45327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
45328   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45329   float arg2 ;
45330
45331   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45332   arg2 = (float)jarg2;
45333   {
45334     try {
45335       (arg1)->SetMaxFlickSpeed(arg2);
45336     } CALL_CATCH_EXCEPTION();
45337   }
45338
45339 }
45340
45341
45342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
45343   void * jresult ;
45344   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45345   Dali::Vector2 result;
45346
45347   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45348   {
45349     try {
45350       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
45351     } CALL_CATCH_EXCEPTION(0);
45352   }
45353
45354   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
45355   return jresult;
45356 }
45357
45358
45359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
45360   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45361   Dali::Vector2 arg2 ;
45362   Dali::Vector2 *argp2 ;
45363
45364   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45365   argp2 = (Dali::Vector2 *)jarg2;
45366   if (!argp2) {
45367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
45368     return ;
45369   }
45370   arg2 = *argp2;
45371   {
45372     try {
45373       (arg1)->SetWheelScrollDistanceStep(arg2);
45374     } CALL_CATCH_EXCEPTION();
45375   }
45376
45377 }
45378
45379
45380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
45381   void * jresult ;
45382   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45383   Dali::Vector2 result;
45384
45385   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45386   {
45387     try {
45388       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
45389     } CALL_CATCH_EXCEPTION(0);
45390   }
45391
45392   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
45393   return jresult;
45394 }
45395
45396
45397 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
45398   unsigned int jresult ;
45399   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45400   unsigned int result;
45401
45402   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45403   {
45404     try {
45405       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
45406     } CALL_CATCH_EXCEPTION(0);
45407   }
45408
45409   jresult = result;
45410   return jresult;
45411 }
45412
45413
45414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
45415   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45416   Dali::Vector2 *arg2 = 0 ;
45417
45418   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45419   arg2 = (Dali::Vector2 *)jarg2;
45420   if (!arg2) {
45421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
45422     return ;
45423   }
45424   {
45425     try {
45426       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
45427     } CALL_CATCH_EXCEPTION();
45428   }
45429
45430 }
45431
45432
45433 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
45434   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45435   Dali::Vector2 *arg2 = 0 ;
45436   float arg3 ;
45437
45438   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45439   arg2 = (Dali::Vector2 *)jarg2;
45440   if (!arg2) {
45441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
45442     return ;
45443   }
45444   arg3 = (float)jarg3;
45445   {
45446     try {
45447       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
45448     } CALL_CATCH_EXCEPTION();
45449   }
45450
45451 }
45452
45453
45454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
45455   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45456   Dali::Vector2 *arg2 = 0 ;
45457   float arg3 ;
45458   Dali::AlphaFunction arg4 ;
45459   Dali::AlphaFunction *argp4 ;
45460
45461   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45462   arg2 = (Dali::Vector2 *)jarg2;
45463   if (!arg2) {
45464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
45465     return ;
45466   }
45467   arg3 = (float)jarg3;
45468   argp4 = (Dali::AlphaFunction *)jarg4;
45469   if (!argp4) {
45470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
45471     return ;
45472   }
45473   arg4 = *argp4;
45474   {
45475     try {
45476       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
45477     } CALL_CATCH_EXCEPTION();
45478   }
45479
45480 }
45481
45482
45483 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
45484   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45485   Dali::Vector2 *arg2 = 0 ;
45486   float arg3 ;
45487   Dali::Toolkit::DirectionBias arg4 ;
45488   Dali::Toolkit::DirectionBias arg5 ;
45489
45490   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45491   arg2 = (Dali::Vector2 *)jarg2;
45492   if (!arg2) {
45493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
45494     return ;
45495   }
45496   arg3 = (float)jarg3;
45497   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
45498   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
45499   {
45500     try {
45501       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
45502     } CALL_CATCH_EXCEPTION();
45503   }
45504
45505 }
45506
45507
45508 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
45509   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45510   Dali::Vector2 *arg2 = 0 ;
45511   float arg3 ;
45512   Dali::AlphaFunction arg4 ;
45513   Dali::Toolkit::DirectionBias arg5 ;
45514   Dali::Toolkit::DirectionBias arg6 ;
45515   Dali::AlphaFunction *argp4 ;
45516
45517   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45518   arg2 = (Dali::Vector2 *)jarg2;
45519   if (!arg2) {
45520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
45521     return ;
45522   }
45523   arg3 = (float)jarg3;
45524   argp4 = (Dali::AlphaFunction *)jarg4;
45525   if (!argp4) {
45526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
45527     return ;
45528   }
45529   arg4 = *argp4;
45530   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
45531   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
45532   {
45533     try {
45534       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
45535     } CALL_CATCH_EXCEPTION();
45536   }
45537
45538 }
45539
45540
45541 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
45542   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45543   unsigned int arg2 ;
45544
45545   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45546   arg2 = (unsigned int)jarg2;
45547   {
45548     try {
45549       (arg1)->ScrollTo(arg2);
45550     } CALL_CATCH_EXCEPTION();
45551   }
45552
45553 }
45554
45555
45556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
45557   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45558   unsigned int arg2 ;
45559   float arg3 ;
45560
45561   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45562   arg2 = (unsigned int)jarg2;
45563   arg3 = (float)jarg3;
45564   {
45565     try {
45566       (arg1)->ScrollTo(arg2,arg3);
45567     } CALL_CATCH_EXCEPTION();
45568   }
45569
45570 }
45571
45572
45573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
45574   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45575   unsigned int arg2 ;
45576   float arg3 ;
45577   Dali::Toolkit::DirectionBias arg4 ;
45578
45579   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45580   arg2 = (unsigned int)jarg2;
45581   arg3 = (float)jarg3;
45582   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
45583   {
45584     try {
45585       (arg1)->ScrollTo(arg2,arg3,arg4);
45586     } CALL_CATCH_EXCEPTION();
45587   }
45588
45589 }
45590
45591
45592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
45593   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45594   Dali::Actor *arg2 = 0 ;
45595
45596   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45597   arg2 = (Dali::Actor *)jarg2;
45598   if (!arg2) {
45599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
45600     return ;
45601   }
45602   {
45603     try {
45604       (arg1)->ScrollTo(*arg2);
45605     } CALL_CATCH_EXCEPTION();
45606   }
45607
45608 }
45609
45610
45611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
45612   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45613   Dali::Actor *arg2 = 0 ;
45614   float arg3 ;
45615
45616   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45617   arg2 = (Dali::Actor *)jarg2;
45618   if (!arg2) {
45619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
45620     return ;
45621   }
45622   arg3 = (float)jarg3;
45623   {
45624     try {
45625       (arg1)->ScrollTo(*arg2,arg3);
45626     } CALL_CATCH_EXCEPTION();
45627   }
45628
45629 }
45630
45631
45632 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
45633   unsigned int jresult ;
45634   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45635   bool result;
45636
45637   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45638   {
45639     try {
45640       result = (bool)(arg1)->ScrollToSnapPoint();
45641     } CALL_CATCH_EXCEPTION(0);
45642   }
45643
45644   jresult = result;
45645   return jresult;
45646 }
45647
45648
45649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
45650   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45651   Dali::Constraint arg2 ;
45652   Dali::Constraint *argp2 ;
45653
45654   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45655   argp2 = (Dali::Constraint *)jarg2;
45656   if (!argp2) {
45657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
45658     return ;
45659   }
45660   arg2 = *argp2;
45661   {
45662     try {
45663       (arg1)->ApplyConstraintToChildren(arg2);
45664     } CALL_CATCH_EXCEPTION();
45665   }
45666
45667 }
45668
45669
45670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
45671   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45672
45673   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45674   {
45675     try {
45676       (arg1)->RemoveConstraintsFromChildren();
45677     } CALL_CATCH_EXCEPTION();
45678   }
45679
45680 }
45681
45682
45683 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
45684   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45685   Dali::Toolkit::ScrollViewEffect arg2 ;
45686   Dali::Toolkit::ScrollViewEffect *argp2 ;
45687
45688   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45689   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
45690   if (!argp2) {
45691     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
45692     return ;
45693   }
45694   arg2 = *argp2;
45695   {
45696     try {
45697       (arg1)->ApplyEffect(arg2);
45698     } CALL_CATCH_EXCEPTION();
45699   }
45700
45701 }
45702
45703
45704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
45705   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45706   Dali::Toolkit::ScrollViewEffect arg2 ;
45707   Dali::Toolkit::ScrollViewEffect *argp2 ;
45708
45709   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45710   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
45711   if (!argp2) {
45712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
45713     return ;
45714   }
45715   arg2 = *argp2;
45716   {
45717     try {
45718       (arg1)->RemoveEffect(arg2);
45719     } CALL_CATCH_EXCEPTION();
45720   }
45721
45722 }
45723
45724
45725 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
45726   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45727
45728   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45729   {
45730     try {
45731       (arg1)->RemoveAllEffects();
45732     } CALL_CATCH_EXCEPTION();
45733   }
45734
45735 }
45736
45737
45738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
45739   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45740   Dali::Actor arg2 ;
45741   Dali::Actor *argp2 ;
45742
45743   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45744   argp2 = (Dali::Actor *)jarg2;
45745   if (!argp2) {
45746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
45747     return ;
45748   }
45749   arg2 = *argp2;
45750   {
45751     try {
45752       (arg1)->BindActor(arg2);
45753     } CALL_CATCH_EXCEPTION();
45754   }
45755
45756 }
45757
45758
45759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
45760   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45761   Dali::Actor arg2 ;
45762   Dali::Actor *argp2 ;
45763
45764   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45765   argp2 = (Dali::Actor *)jarg2;
45766   if (!argp2) {
45767     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
45768     return ;
45769   }
45770   arg2 = *argp2;
45771   {
45772     try {
45773       (arg1)->UnbindActor(arg2);
45774     } CALL_CATCH_EXCEPTION();
45775   }
45776
45777 }
45778
45779
45780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
45781   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45782   Dali::Radian arg2 ;
45783   Dali::Radian arg3 ;
45784   Dali::Radian *argp2 ;
45785   Dali::Radian *argp3 ;
45786
45787   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45788   argp2 = (Dali::Radian *)jarg2;
45789   if (!argp2) {
45790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
45791     return ;
45792   }
45793   arg2 = *argp2;
45794   argp3 = (Dali::Radian *)jarg3;
45795   if (!argp3) {
45796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
45797     return ;
45798   }
45799   arg3 = *argp3;
45800   {
45801     try {
45802       (arg1)->SetScrollingDirection(arg2,arg3);
45803     } CALL_CATCH_EXCEPTION();
45804   }
45805
45806 }
45807
45808
45809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
45810   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45811   Dali::Radian arg2 ;
45812   Dali::Radian *argp2 ;
45813
45814   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45815   argp2 = (Dali::Radian *)jarg2;
45816   if (!argp2) {
45817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
45818     return ;
45819   }
45820   arg2 = *argp2;
45821   {
45822     try {
45823       (arg1)->SetScrollingDirection(arg2);
45824     } CALL_CATCH_EXCEPTION();
45825   }
45826
45827 }
45828
45829
45830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
45831   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45832   Dali::Radian arg2 ;
45833   Dali::Radian *argp2 ;
45834
45835   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45836   argp2 = (Dali::Radian *)jarg2;
45837   if (!argp2) {
45838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
45839     return ;
45840   }
45841   arg2 = *argp2;
45842   {
45843     try {
45844       (arg1)->RemoveScrollingDirection(arg2);
45845     } CALL_CATCH_EXCEPTION();
45846   }
45847
45848 }
45849
45850
45851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
45852   void * jresult ;
45853   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45854   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
45855
45856   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45857   {
45858     try {
45859       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
45860     } CALL_CATCH_EXCEPTION(0);
45861   }
45862
45863   jresult = (void *)result;
45864   return jresult;
45865 }
45866
45867
45868 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
45869   int jresult ;
45870   int result;
45871
45872   result = (int)Dali::Toolkit::TableView::Property::ROWS;
45873   jresult = (int)result;
45874   return jresult;
45875 }
45876
45877
45878 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
45879   int jresult ;
45880   int result;
45881
45882   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
45883   jresult = (int)result;
45884   return jresult;
45885 }
45886
45887
45888 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
45889   int jresult ;
45890   int result;
45891
45892   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
45893   jresult = (int)result;
45894   return jresult;
45895 }
45896
45897
45898 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
45899   int jresult ;
45900   int result;
45901
45902   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
45903   jresult = (int)result;
45904   return jresult;
45905 }
45906
45907
45908 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
45909   int jresult ;
45910   int result;
45911
45912   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
45913   jresult = (int)result;
45914   return jresult;
45915 }
45916
45917
45918 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
45919   void * jresult ;
45920   Dali::Toolkit::TableView::Property *result = 0 ;
45921
45922   {
45923     try {
45924       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
45925     } CALL_CATCH_EXCEPTION(0);
45926   }
45927
45928   jresult = (void *)result;
45929   return jresult;
45930 }
45931
45932
45933 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
45934   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
45935
45936   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
45937   {
45938     try {
45939       delete arg1;
45940     } CALL_CATCH_EXCEPTION();
45941   }
45942
45943 }
45944
45945
45946 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
45947   int jresult ;
45948   int result;
45949
45950   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
45951   jresult = (int)result;
45952   return jresult;
45953 }
45954
45955
45956 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
45957   int jresult ;
45958   int result;
45959
45960   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
45961   jresult = (int)result;
45962   return jresult;
45963 }
45964
45965
45966 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
45967   int jresult ;
45968   int result;
45969
45970   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
45971   jresult = (int)result;
45972   return jresult;
45973 }
45974
45975
45976 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
45977   int jresult ;
45978   int result;
45979
45980   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
45981   jresult = (int)result;
45982   return jresult;
45983 }
45984
45985
45986 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
45987   int jresult ;
45988   int result;
45989
45990   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
45991   jresult = (int)result;
45992   return jresult;
45993 }
45994
45995
45996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
45997   void * jresult ;
45998   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
45999
46000   {
46001     try {
46002       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
46003     } CALL_CATCH_EXCEPTION(0);
46004   }
46005
46006   jresult = (void *)result;
46007   return jresult;
46008 }
46009
46010
46011 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
46012   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
46013
46014   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
46015   {
46016     try {
46017       delete arg1;
46018     } CALL_CATCH_EXCEPTION();
46019   }
46020
46021 }
46022
46023
46024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
46025   void * jresult ;
46026   unsigned int arg1 ;
46027   unsigned int arg2 ;
46028   unsigned int arg3 ;
46029   unsigned int arg4 ;
46030   Dali::Toolkit::TableView::CellPosition *result = 0 ;
46031
46032   arg1 = (unsigned int)jarg1;
46033   arg2 = (unsigned int)jarg2;
46034   arg3 = (unsigned int)jarg3;
46035   arg4 = (unsigned int)jarg4;
46036   {
46037     try {
46038       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
46039     } CALL_CATCH_EXCEPTION(0);
46040   }
46041
46042   jresult = (void *)result;
46043   return jresult;
46044 }
46045
46046
46047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
46048   void * jresult ;
46049   unsigned int arg1 ;
46050   unsigned int arg2 ;
46051   unsigned int arg3 ;
46052   Dali::Toolkit::TableView::CellPosition *result = 0 ;
46053
46054   arg1 = (unsigned int)jarg1;
46055   arg2 = (unsigned int)jarg2;
46056   arg3 = (unsigned int)jarg3;
46057   {
46058     try {
46059       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
46060     } CALL_CATCH_EXCEPTION(0);
46061   }
46062
46063   jresult = (void *)result;
46064   return jresult;
46065 }
46066
46067
46068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
46069   void * jresult ;
46070   unsigned int arg1 ;
46071   unsigned int arg2 ;
46072   Dali::Toolkit::TableView::CellPosition *result = 0 ;
46073
46074   arg1 = (unsigned int)jarg1;
46075   arg2 = (unsigned int)jarg2;
46076   {
46077     try {
46078       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
46079     } CALL_CATCH_EXCEPTION(0);
46080   }
46081
46082   jresult = (void *)result;
46083   return jresult;
46084 }
46085
46086
46087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
46088   void * jresult ;
46089   unsigned int arg1 ;
46090   Dali::Toolkit::TableView::CellPosition *result = 0 ;
46091
46092   arg1 = (unsigned int)jarg1;
46093   {
46094     try {
46095       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
46096     } CALL_CATCH_EXCEPTION(0);
46097   }
46098
46099   jresult = (void *)result;
46100   return jresult;
46101 }
46102
46103
46104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
46105   void * jresult ;
46106   Dali::Toolkit::TableView::CellPosition *result = 0 ;
46107
46108   {
46109     try {
46110       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
46111     } CALL_CATCH_EXCEPTION(0);
46112   }
46113
46114   jresult = (void *)result;
46115   return jresult;
46116 }
46117
46118
46119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
46120   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
46121   unsigned int arg2 ;
46122
46123   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
46124   arg2 = (unsigned int)jarg2;
46125   if (arg1) (arg1)->rowIndex = arg2;
46126 }
46127
46128
46129 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
46130   unsigned int jresult ;
46131   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
46132   unsigned int result;
46133
46134   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
46135   result = (unsigned int) ((arg1)->rowIndex);
46136   jresult = result;
46137   return jresult;
46138 }
46139
46140
46141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
46142   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
46143   unsigned int arg2 ;
46144
46145   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
46146   arg2 = (unsigned int)jarg2;
46147   if (arg1) (arg1)->columnIndex = arg2;
46148 }
46149
46150
46151 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
46152   unsigned int jresult ;
46153   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
46154   unsigned int result;
46155
46156   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
46157   result = (unsigned int) ((arg1)->columnIndex);
46158   jresult = result;
46159   return jresult;
46160 }
46161
46162
46163 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
46164   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
46165   unsigned int arg2 ;
46166
46167   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
46168   arg2 = (unsigned int)jarg2;
46169   if (arg1) (arg1)->rowSpan = arg2;
46170 }
46171
46172
46173 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
46174   unsigned int jresult ;
46175   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
46176   unsigned int result;
46177
46178   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
46179   result = (unsigned int) ((arg1)->rowSpan);
46180   jresult = result;
46181   return jresult;
46182 }
46183
46184
46185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
46186   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
46187   unsigned int arg2 ;
46188
46189   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
46190   arg2 = (unsigned int)jarg2;
46191   if (arg1) (arg1)->columnSpan = arg2;
46192 }
46193
46194
46195 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
46196   unsigned int jresult ;
46197   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
46198   unsigned int result;
46199
46200   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
46201   result = (unsigned int) ((arg1)->columnSpan);
46202   jresult = result;
46203   return jresult;
46204 }
46205
46206
46207 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
46208   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
46209
46210   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
46211   {
46212     try {
46213       delete arg1;
46214     } CALL_CATCH_EXCEPTION();
46215   }
46216
46217 }
46218
46219
46220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
46221   void * jresult ;
46222   Dali::Toolkit::TableView *result = 0 ;
46223
46224   {
46225     try {
46226       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
46227     } CALL_CATCH_EXCEPTION(0);
46228   }
46229
46230   jresult = (void *)result;
46231   return jresult;
46232 }
46233
46234
46235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
46236   void * jresult ;
46237   Dali::Toolkit::TableView *arg1 = 0 ;
46238   Dali::Toolkit::TableView *result = 0 ;
46239
46240   arg1 = (Dali::Toolkit::TableView *)jarg1;
46241   if (!arg1) {
46242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
46243     return 0;
46244   }
46245   {
46246     try {
46247       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
46248     } CALL_CATCH_EXCEPTION(0);
46249   }
46250
46251   jresult = (void *)result;
46252   return jresult;
46253 }
46254
46255
46256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
46257   void * jresult ;
46258   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46259   Dali::Toolkit::TableView *arg2 = 0 ;
46260   Dali::Toolkit::TableView *result = 0 ;
46261
46262   arg1 = (Dali::Toolkit::TableView *)jarg1;
46263   arg2 = (Dali::Toolkit::TableView *)jarg2;
46264   if (!arg2) {
46265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
46266     return 0;
46267   }
46268   {
46269     try {
46270       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
46271     } CALL_CATCH_EXCEPTION(0);
46272   }
46273
46274   jresult = (void *)result;
46275   return jresult;
46276 }
46277
46278
46279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
46280   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46281
46282   arg1 = (Dali::Toolkit::TableView *)jarg1;
46283   {
46284     try {
46285       delete arg1;
46286     } CALL_CATCH_EXCEPTION();
46287   }
46288
46289 }
46290
46291
46292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
46293   void * jresult ;
46294   unsigned int arg1 ;
46295   unsigned int arg2 ;
46296   Dali::Toolkit::TableView result;
46297
46298   arg1 = (unsigned int)jarg1;
46299   arg2 = (unsigned int)jarg2;
46300   {
46301     try {
46302       result = Dali::Toolkit::TableView::New(arg1,arg2);
46303     } CALL_CATCH_EXCEPTION(0);
46304   }
46305
46306   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
46307   return jresult;
46308 }
46309
46310
46311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
46312   void * jresult ;
46313   Dali::BaseHandle arg1 ;
46314   Dali::BaseHandle *argp1 ;
46315   Dali::Toolkit::TableView result;
46316
46317   argp1 = (Dali::BaseHandle *)jarg1;
46318   if (!argp1) {
46319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
46320     return 0;
46321   }
46322   arg1 = *argp1;
46323   {
46324     try {
46325       result = Dali::Toolkit::TableView::DownCast(arg1);
46326     } CALL_CATCH_EXCEPTION(0);
46327   }
46328
46329   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
46330   return jresult;
46331 }
46332
46333
46334 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
46335   unsigned int jresult ;
46336   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46337   Dali::Actor arg2 ;
46338   Dali::Toolkit::TableView::CellPosition arg3 ;
46339   Dali::Actor *argp2 ;
46340   Dali::Toolkit::TableView::CellPosition *argp3 ;
46341   bool result;
46342
46343   arg1 = (Dali::Toolkit::TableView *)jarg1;
46344   argp2 = (Dali::Actor *)jarg2;
46345   if (!argp2) {
46346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
46347     return 0;
46348   }
46349   arg2 = *argp2;
46350   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
46351   if (!argp3) {
46352     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
46353     return 0;
46354   }
46355   arg3 = *argp3;
46356   {
46357     try {
46358       result = (bool)(arg1)->AddChild(arg2,arg3);
46359     } CALL_CATCH_EXCEPTION(0);
46360   }
46361
46362   jresult = result;
46363   return jresult;
46364 }
46365
46366
46367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
46368   void * jresult ;
46369   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46370   Dali::Toolkit::TableView::CellPosition arg2 ;
46371   Dali::Toolkit::TableView::CellPosition *argp2 ;
46372   Dali::Actor result;
46373
46374   arg1 = (Dali::Toolkit::TableView *)jarg1;
46375   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
46376   if (!argp2) {
46377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
46378     return 0;
46379   }
46380   arg2 = *argp2;
46381   {
46382     try {
46383       result = (arg1)->GetChildAt(arg2);
46384     } CALL_CATCH_EXCEPTION(0);
46385   }
46386
46387   jresult = new Dali::Actor((const Dali::Actor &)result);
46388   return jresult;
46389 }
46390
46391
46392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
46393   void * jresult ;
46394   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46395   Dali::Toolkit::TableView::CellPosition arg2 ;
46396   Dali::Toolkit::TableView::CellPosition *argp2 ;
46397   Dali::Actor result;
46398
46399   arg1 = (Dali::Toolkit::TableView *)jarg1;
46400   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
46401   if (!argp2) {
46402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
46403     return 0;
46404   }
46405   arg2 = *argp2;
46406   {
46407     try {
46408       result = (arg1)->RemoveChildAt(arg2);
46409     } CALL_CATCH_EXCEPTION(0);
46410   }
46411
46412   jresult = new Dali::Actor((const Dali::Actor &)result);
46413   return jresult;
46414 }
46415
46416
46417 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
46418   unsigned int jresult ;
46419   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46420   Dali::Actor arg2 ;
46421   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
46422   Dali::Actor *argp2 ;
46423   bool result;
46424
46425   arg1 = (Dali::Toolkit::TableView *)jarg1;
46426   argp2 = (Dali::Actor *)jarg2;
46427   if (!argp2) {
46428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
46429     return 0;
46430   }
46431   arg2 = *argp2;
46432   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
46433   if (!arg3) {
46434     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
46435     return 0;
46436   }
46437   {
46438     try {
46439       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
46440     } CALL_CATCH_EXCEPTION(0);
46441   }
46442
46443   jresult = result;
46444   return jresult;
46445 }
46446
46447
46448 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
46449   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46450   unsigned int arg2 ;
46451
46452   arg1 = (Dali::Toolkit::TableView *)jarg1;
46453   arg2 = (unsigned int)jarg2;
46454   {
46455     try {
46456       (arg1)->InsertRow(arg2);
46457     } CALL_CATCH_EXCEPTION();
46458   }
46459
46460 }
46461
46462
46463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
46464   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46465   unsigned int arg2 ;
46466
46467   arg1 = (Dali::Toolkit::TableView *)jarg1;
46468   arg2 = (unsigned int)jarg2;
46469   {
46470     try {
46471       (arg1)->DeleteRow(arg2);
46472     } CALL_CATCH_EXCEPTION();
46473   }
46474
46475 }
46476
46477
46478 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
46479   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46480   unsigned int arg2 ;
46481   std::vector< Dali::Actor > *arg3 = 0 ;
46482
46483   arg1 = (Dali::Toolkit::TableView *)jarg1;
46484   arg2 = (unsigned int)jarg2;
46485   arg3 = (std::vector< Dali::Actor > *)jarg3;
46486   if (!arg3) {
46487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
46488     return ;
46489   }
46490   {
46491     try {
46492       (arg1)->DeleteRow(arg2,*arg3);
46493     } CALL_CATCH_EXCEPTION();
46494   }
46495
46496 }
46497
46498
46499 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
46500   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46501   unsigned int arg2 ;
46502
46503   arg1 = (Dali::Toolkit::TableView *)jarg1;
46504   arg2 = (unsigned int)jarg2;
46505   {
46506     try {
46507       (arg1)->InsertColumn(arg2);
46508     } CALL_CATCH_EXCEPTION();
46509   }
46510
46511 }
46512
46513
46514 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
46515   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46516   unsigned int arg2 ;
46517
46518   arg1 = (Dali::Toolkit::TableView *)jarg1;
46519   arg2 = (unsigned int)jarg2;
46520   {
46521     try {
46522       (arg1)->DeleteColumn(arg2);
46523     } CALL_CATCH_EXCEPTION();
46524   }
46525
46526 }
46527
46528
46529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
46530   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46531   unsigned int arg2 ;
46532   std::vector< Dali::Actor > *arg3 = 0 ;
46533
46534   arg1 = (Dali::Toolkit::TableView *)jarg1;
46535   arg2 = (unsigned int)jarg2;
46536   arg3 = (std::vector< Dali::Actor > *)jarg3;
46537   if (!arg3) {
46538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
46539     return ;
46540   }
46541   {
46542     try {
46543       (arg1)->DeleteColumn(arg2,*arg3);
46544     } CALL_CATCH_EXCEPTION();
46545   }
46546
46547 }
46548
46549
46550 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
46551   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46552   unsigned int arg2 ;
46553   unsigned int arg3 ;
46554
46555   arg1 = (Dali::Toolkit::TableView *)jarg1;
46556   arg2 = (unsigned int)jarg2;
46557   arg3 = (unsigned int)jarg3;
46558   {
46559     try {
46560       (arg1)->Resize(arg2,arg3);
46561     } CALL_CATCH_EXCEPTION();
46562   }
46563
46564 }
46565
46566
46567 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
46568   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46569   unsigned int arg2 ;
46570   unsigned int arg3 ;
46571   std::vector< Dali::Actor > *arg4 = 0 ;
46572
46573   arg1 = (Dali::Toolkit::TableView *)jarg1;
46574   arg2 = (unsigned int)jarg2;
46575   arg3 = (unsigned int)jarg3;
46576   arg4 = (std::vector< Dali::Actor > *)jarg4;
46577   if (!arg4) {
46578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
46579     return ;
46580   }
46581   {
46582     try {
46583       (arg1)->Resize(arg2,arg3,*arg4);
46584     } CALL_CATCH_EXCEPTION();
46585   }
46586
46587 }
46588
46589
46590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
46591   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46592   Dali::Size arg2 ;
46593   Dali::Size *argp2 ;
46594
46595   arg1 = (Dali::Toolkit::TableView *)jarg1;
46596   argp2 = (Dali::Size *)jarg2;
46597   if (!argp2) {
46598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
46599     return ;
46600   }
46601   arg2 = *argp2;
46602   {
46603     try {
46604       (arg1)->SetCellPadding(arg2);
46605     } CALL_CATCH_EXCEPTION();
46606   }
46607
46608 }
46609
46610
46611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
46612   void * jresult ;
46613   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46614   Dali::Size result;
46615
46616   arg1 = (Dali::Toolkit::TableView *)jarg1;
46617   {
46618     try {
46619       result = (arg1)->GetCellPadding();
46620     } CALL_CATCH_EXCEPTION(0);
46621   }
46622
46623   jresult = new Dali::Size((const Dali::Size &)result);
46624   return jresult;
46625 }
46626
46627
46628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
46629   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46630   unsigned int arg2 ;
46631
46632   arg1 = (Dali::Toolkit::TableView *)jarg1;
46633   arg2 = (unsigned int)jarg2;
46634   {
46635     try {
46636       (arg1)->SetFitHeight(arg2);
46637     } CALL_CATCH_EXCEPTION();
46638   }
46639
46640 }
46641
46642
46643 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
46644   unsigned int jresult ;
46645   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46646   unsigned int arg2 ;
46647   bool result;
46648
46649   arg1 = (Dali::Toolkit::TableView *)jarg1;
46650   arg2 = (unsigned int)jarg2;
46651   {
46652     try {
46653       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
46654     } CALL_CATCH_EXCEPTION(0);
46655   }
46656
46657   jresult = result;
46658   return jresult;
46659 }
46660
46661
46662 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
46663   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46664   unsigned int arg2 ;
46665
46666   arg1 = (Dali::Toolkit::TableView *)jarg1;
46667   arg2 = (unsigned int)jarg2;
46668   {
46669     try {
46670       (arg1)->SetFitWidth(arg2);
46671     } CALL_CATCH_EXCEPTION();
46672   }
46673
46674 }
46675
46676
46677 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
46678   unsigned int jresult ;
46679   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46680   unsigned int arg2 ;
46681   bool result;
46682
46683   arg1 = (Dali::Toolkit::TableView *)jarg1;
46684   arg2 = (unsigned int)jarg2;
46685   {
46686     try {
46687       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
46688     } CALL_CATCH_EXCEPTION(0);
46689   }
46690
46691   jresult = result;
46692   return jresult;
46693 }
46694
46695
46696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
46697   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46698   unsigned int arg2 ;
46699   float arg3 ;
46700
46701   arg1 = (Dali::Toolkit::TableView *)jarg1;
46702   arg2 = (unsigned int)jarg2;
46703   arg3 = (float)jarg3;
46704   {
46705     try {
46706       (arg1)->SetFixedHeight(arg2,arg3);
46707     } CALL_CATCH_EXCEPTION();
46708   }
46709
46710 }
46711
46712
46713 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
46714   float jresult ;
46715   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46716   unsigned int arg2 ;
46717   float result;
46718
46719   arg1 = (Dali::Toolkit::TableView *)jarg1;
46720   arg2 = (unsigned int)jarg2;
46721   {
46722     try {
46723       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
46724     } CALL_CATCH_EXCEPTION(0);
46725   }
46726
46727   jresult = result;
46728   return jresult;
46729 }
46730
46731
46732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
46733   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46734   unsigned int arg2 ;
46735   float arg3 ;
46736
46737   arg1 = (Dali::Toolkit::TableView *)jarg1;
46738   arg2 = (unsigned int)jarg2;
46739   arg3 = (float)jarg3;
46740   {
46741     try {
46742       (arg1)->SetRelativeHeight(arg2,arg3);
46743     } CALL_CATCH_EXCEPTION();
46744   }
46745
46746 }
46747
46748
46749 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
46750   float jresult ;
46751   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46752   unsigned int arg2 ;
46753   float result;
46754
46755   arg1 = (Dali::Toolkit::TableView *)jarg1;
46756   arg2 = (unsigned int)jarg2;
46757   {
46758     try {
46759       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
46760     } CALL_CATCH_EXCEPTION(0);
46761   }
46762
46763   jresult = result;
46764   return jresult;
46765 }
46766
46767
46768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
46769   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46770   unsigned int arg2 ;
46771   float arg3 ;
46772
46773   arg1 = (Dali::Toolkit::TableView *)jarg1;
46774   arg2 = (unsigned int)jarg2;
46775   arg3 = (float)jarg3;
46776   {
46777     try {
46778       (arg1)->SetFixedWidth(arg2,arg3);
46779     } CALL_CATCH_EXCEPTION();
46780   }
46781
46782 }
46783
46784
46785 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
46786   float jresult ;
46787   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46788   unsigned int arg2 ;
46789   float result;
46790
46791   arg1 = (Dali::Toolkit::TableView *)jarg1;
46792   arg2 = (unsigned int)jarg2;
46793   {
46794     try {
46795       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
46796     } CALL_CATCH_EXCEPTION(0);
46797   }
46798
46799   jresult = result;
46800   return jresult;
46801 }
46802
46803
46804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
46805   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46806   unsigned int arg2 ;
46807   float arg3 ;
46808
46809   arg1 = (Dali::Toolkit::TableView *)jarg1;
46810   arg2 = (unsigned int)jarg2;
46811   arg3 = (float)jarg3;
46812   {
46813     try {
46814       (arg1)->SetRelativeWidth(arg2,arg3);
46815     } CALL_CATCH_EXCEPTION();
46816   }
46817
46818 }
46819
46820
46821 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
46822   float jresult ;
46823   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46824   unsigned int arg2 ;
46825   float result;
46826
46827   arg1 = (Dali::Toolkit::TableView *)jarg1;
46828   arg2 = (unsigned int)jarg2;
46829   {
46830     try {
46831       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
46832     } CALL_CATCH_EXCEPTION(0);
46833   }
46834
46835   jresult = result;
46836   return jresult;
46837 }
46838
46839
46840 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
46841   unsigned int jresult ;
46842   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46843   unsigned int result;
46844
46845   arg1 = (Dali::Toolkit::TableView *)jarg1;
46846   {
46847     try {
46848       result = (unsigned int)(arg1)->GetRows();
46849     } CALL_CATCH_EXCEPTION(0);
46850   }
46851
46852   jresult = result;
46853   return jresult;
46854 }
46855
46856
46857 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
46858   unsigned int jresult ;
46859   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46860   unsigned int result;
46861
46862   arg1 = (Dali::Toolkit::TableView *)jarg1;
46863   {
46864     try {
46865       result = (unsigned int)(arg1)->GetColumns();
46866     } CALL_CATCH_EXCEPTION(0);
46867   }
46868
46869   jresult = result;
46870   return jresult;
46871 }
46872
46873
46874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
46875   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46876   Dali::Toolkit::TableView::CellPosition arg2 ;
46877   Dali::HorizontalAlignment::Type arg3 ;
46878   Dali::VerticalAlignment::Type arg4 ;
46879   Dali::Toolkit::TableView::CellPosition *argp2 ;
46880
46881   arg1 = (Dali::Toolkit::TableView *)jarg1;
46882   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
46883   if (!argp2) {
46884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
46885     return ;
46886   }
46887   arg2 = *argp2;
46888   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
46889   arg4 = (Dali::VerticalAlignment::Type)jarg4;
46890   {
46891     try {
46892       (arg1)->SetCellAlignment(arg2,arg3,arg4);
46893     } CALL_CATCH_EXCEPTION();
46894   }
46895
46896 }
46897
46898
46899 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
46900   unsigned int jresult ;
46901   unsigned int result;
46902
46903   result = (unsigned int)(unsigned int)Dali::Toolkit::DevelText::DEFAULT_RENDERING_BACKEND;
46904   jresult = result;
46905   return jresult;
46906 }
46907
46908
46909 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
46910   int jresult ;
46911   int result;
46912
46913   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
46914   jresult = (int)result;
46915   return jresult;
46916 }
46917
46918
46919 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
46920   int jresult ;
46921   int result;
46922
46923   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
46924   jresult = (int)result;
46925   return jresult;
46926 }
46927
46928
46929 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
46930   int jresult ;
46931   int result;
46932
46933   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
46934   jresult = (int)result;
46935   return jresult;
46936 }
46937
46938
46939 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
46940   int jresult ;
46941   int result;
46942
46943   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
46944   jresult = (int)result;
46945   return jresult;
46946 }
46947
46948
46949 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
46950   int jresult ;
46951   int result;
46952
46953   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
46954   jresult = (int)result;
46955   return jresult;
46956 }
46957
46958
46959 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
46960   int jresult ;
46961   int result;
46962
46963   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
46964   jresult = (int)result;
46965   return jresult;
46966 }
46967
46968
46969 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
46970   int jresult ;
46971   int result;
46972
46973   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
46974   jresult = (int)result;
46975   return jresult;
46976 }
46977
46978
46979 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
46980   int jresult ;
46981   int result;
46982
46983   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
46984   jresult = (int)result;
46985   return jresult;
46986 }
46987
46988
46989 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
46990   int jresult ;
46991   int result;
46992
46993   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
46994   jresult = (int)result;
46995   return jresult;
46996 }
46997
46998
46999 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
47000   int jresult ;
47001   int result;
47002
47003   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
47004   jresult = (int)result;
47005   return jresult;
47006 }
47007
47008
47009 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
47010   int jresult ;
47011   int result;
47012
47013   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
47014   jresult = (int)result;
47015   return jresult;
47016 }
47017
47018
47019 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
47020   int jresult ;
47021   int result;
47022
47023   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
47024   jresult = (int)result;
47025   return jresult;
47026 }
47027
47028
47029 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
47030   int jresult ;
47031   int result;
47032
47033   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
47034   jresult = (int)result;
47035   return jresult;
47036 }
47037
47038
47039 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
47040   int jresult ;
47041   int result;
47042
47043   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
47044   jresult = (int)result;
47045   return jresult;
47046 }
47047
47048
47049 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
47050   int jresult ;
47051   int result;
47052
47053   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
47054   jresult = (int)result;
47055   return jresult;
47056 }
47057
47058
47059 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
47060   int jresult ;
47061   int result;
47062
47063   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
47064   jresult = (int)result;
47065   return jresult;
47066 }
47067
47068
47069 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
47070   int jresult ;
47071   int result;
47072
47073   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
47074   jresult = (int)result;
47075   return jresult;
47076 }
47077
47078
47079 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
47080   int jresult ;
47081   int result;
47082
47083   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
47084   jresult = (int)result;
47085   return jresult;
47086 }
47087
47088
47089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
47090   void * jresult ;
47091   Dali::Toolkit::TextLabel::Property *result = 0 ;
47092
47093   {
47094     try {
47095       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
47096     } CALL_CATCH_EXCEPTION(0);
47097   }
47098
47099   jresult = (void *)result;
47100   return jresult;
47101 }
47102
47103
47104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
47105   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
47106
47107   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
47108   {
47109     try {
47110       delete arg1;
47111     } CALL_CATCH_EXCEPTION();
47112   }
47113
47114 }
47115
47116
47117 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
47118   void * jresult ;
47119   Dali::Toolkit::TextLabel result;
47120
47121   {
47122     try {
47123       result = Dali::Toolkit::TextLabel::New();
47124     } CALL_CATCH_EXCEPTION(0);
47125   }
47126
47127   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
47128   return jresult;
47129 }
47130
47131
47132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
47133   void * jresult ;
47134   std::string *arg1 = 0 ;
47135   Dali::Toolkit::TextLabel result;
47136
47137   if (!jarg1) {
47138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
47139     return 0;
47140   }
47141   std::string arg1_str(jarg1);
47142   arg1 = &arg1_str;
47143   {
47144     try {
47145       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
47146     } CALL_CATCH_EXCEPTION(0);
47147   }
47148
47149   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
47150
47151   //argout typemap for const std::string&
47152
47153   return jresult;
47154 }
47155
47156
47157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
47158   void * jresult ;
47159   Dali::Toolkit::TextLabel *result = 0 ;
47160
47161   {
47162     try {
47163       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
47164     } CALL_CATCH_EXCEPTION(0);
47165   }
47166
47167   jresult = (void *)result;
47168   return jresult;
47169 }
47170
47171
47172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
47173   void * jresult ;
47174   Dali::Toolkit::TextLabel *arg1 = 0 ;
47175   Dali::Toolkit::TextLabel *result = 0 ;
47176
47177   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
47178   if (!arg1) {
47179     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
47180     return 0;
47181   }
47182   {
47183     try {
47184       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
47185     } CALL_CATCH_EXCEPTION(0);
47186   }
47187
47188   jresult = (void *)result;
47189   return jresult;
47190 }
47191
47192
47193 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
47194   void * jresult ;
47195   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
47196   Dali::Toolkit::TextLabel *arg2 = 0 ;
47197   Dali::Toolkit::TextLabel *result = 0 ;
47198
47199   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
47200   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
47201   if (!arg2) {
47202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
47203     return 0;
47204   }
47205   {
47206     try {
47207       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
47208     } CALL_CATCH_EXCEPTION(0);
47209   }
47210
47211   jresult = (void *)result;
47212   return jresult;
47213 }
47214
47215
47216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
47217   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
47218
47219   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
47220   {
47221     try {
47222       delete arg1;
47223     } CALL_CATCH_EXCEPTION();
47224   }
47225
47226 }
47227
47228
47229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
47230   void * jresult ;
47231   Dali::BaseHandle arg1 ;
47232   Dali::BaseHandle *argp1 ;
47233   Dali::Toolkit::TextLabel result;
47234
47235   argp1 = (Dali::BaseHandle *)jarg1;
47236   if (!argp1) {
47237     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
47238     return 0;
47239   }
47240   arg1 = *argp1;
47241   {
47242     try {
47243       result = Dali::Toolkit::TextLabel::DownCast(arg1);
47244     } CALL_CATCH_EXCEPTION(0);
47245   }
47246
47247   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
47248   return jresult;
47249 }
47250
47251
47252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
47253   void * jresult ;
47254   Dali::Toolkit::AccessibilityManager *result = 0 ;
47255
47256   {
47257     try {
47258       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
47259     } CALL_CATCH_EXCEPTION(0);
47260   }
47261
47262   jresult = (void *)result;
47263   return jresult;
47264 }
47265
47266
47267 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
47268   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47269
47270   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47271   {
47272     try {
47273       delete arg1;
47274     } CALL_CATCH_EXCEPTION();
47275   }
47276
47277 }
47278
47279
47280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
47281   void * jresult ;
47282   Dali::Toolkit::AccessibilityManager result;
47283
47284   {
47285     try {
47286       result = Dali::Toolkit::AccessibilityManager::Get();
47287     } CALL_CATCH_EXCEPTION(0);
47288   }
47289
47290   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
47291   return jresult;
47292 }
47293
47294
47295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
47296   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47297   Dali::Actor arg2 ;
47298   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
47299   std::string *arg4 = 0 ;
47300   Dali::Actor *argp2 ;
47301
47302   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47303   argp2 = (Dali::Actor *)jarg2;
47304   if (!argp2) {
47305     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
47306     return ;
47307   }
47308   arg2 = *argp2;
47309   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
47310   if (!jarg4) {
47311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
47312     return ;
47313   }
47314   std::string arg4_str(jarg4);
47315   arg4 = &arg4_str;
47316   {
47317     try {
47318       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
47319     } CALL_CATCH_EXCEPTION();
47320   }
47321
47322
47323   //argout typemap for const std::string&
47324
47325 }
47326
47327
47328 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
47329   char * jresult ;
47330   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47331   Dali::Actor arg2 ;
47332   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
47333   Dali::Actor *argp2 ;
47334   std::string result;
47335
47336   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47337   argp2 = (Dali::Actor *)jarg2;
47338   if (!argp2) {
47339     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
47340     return 0;
47341   }
47342   arg2 = *argp2;
47343   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
47344   {
47345     try {
47346       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
47347     } CALL_CATCH_EXCEPTION(0);
47348   }
47349
47350   jresult = SWIG_csharp_string_callback((&result)->c_str());
47351   return jresult;
47352 }
47353
47354
47355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
47356   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47357   Dali::Actor arg2 ;
47358   unsigned int arg3 ;
47359   Dali::Actor *argp2 ;
47360
47361   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47362   argp2 = (Dali::Actor *)jarg2;
47363   if (!argp2) {
47364     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
47365     return ;
47366   }
47367   arg2 = *argp2;
47368   arg3 = (unsigned int)jarg3;
47369   {
47370     try {
47371       (arg1)->SetFocusOrder(arg2,arg3);
47372     } CALL_CATCH_EXCEPTION();
47373   }
47374
47375 }
47376
47377
47378 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
47379   unsigned int jresult ;
47380   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47381   Dali::Actor arg2 ;
47382   Dali::Actor *argp2 ;
47383   unsigned int result;
47384
47385   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47386   argp2 = (Dali::Actor *)jarg2;
47387   if (!argp2) {
47388     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
47389     return 0;
47390   }
47391   arg2 = *argp2;
47392   {
47393     try {
47394       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
47395     } CALL_CATCH_EXCEPTION(0);
47396   }
47397
47398   jresult = result;
47399   return jresult;
47400 }
47401
47402
47403 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
47404   unsigned int jresult ;
47405   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47406   unsigned int result;
47407
47408   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47409   {
47410     try {
47411       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
47412     } CALL_CATCH_EXCEPTION(0);
47413   }
47414
47415   jresult = result;
47416   return jresult;
47417 }
47418
47419
47420 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
47421   void * jresult ;
47422   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47423   unsigned int arg2 ;
47424   Dali::Actor result;
47425
47426   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47427   arg2 = (unsigned int)jarg2;
47428   {
47429     try {
47430       result = (arg1)->GetActorByFocusOrder(arg2);
47431     } CALL_CATCH_EXCEPTION(0);
47432   }
47433
47434   jresult = new Dali::Actor((const Dali::Actor &)result);
47435   return jresult;
47436 }
47437
47438
47439 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
47440   unsigned int jresult ;
47441   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47442   Dali::Actor arg2 ;
47443   Dali::Actor *argp2 ;
47444   bool result;
47445
47446   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47447   argp2 = (Dali::Actor *)jarg2;
47448   if (!argp2) {
47449     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
47450     return 0;
47451   }
47452   arg2 = *argp2;
47453   {
47454     try {
47455       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
47456     } CALL_CATCH_EXCEPTION(0);
47457   }
47458
47459   jresult = result;
47460   return jresult;
47461 }
47462
47463
47464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
47465   void * jresult ;
47466   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47467   Dali::Actor result;
47468
47469   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47470   {
47471     try {
47472       result = (arg1)->GetCurrentFocusActor();
47473     } CALL_CATCH_EXCEPTION(0);
47474   }
47475
47476   jresult = new Dali::Actor((const Dali::Actor &)result);
47477   return jresult;
47478 }
47479
47480
47481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
47482   void * jresult ;
47483   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47484   Dali::Actor result;
47485
47486   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47487   {
47488     try {
47489       result = (arg1)->GetCurrentFocusGroup();
47490     } CALL_CATCH_EXCEPTION(0);
47491   }
47492
47493   jresult = new Dali::Actor((const Dali::Actor &)result);
47494   return jresult;
47495 }
47496
47497
47498 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
47499   unsigned int jresult ;
47500   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47501   unsigned int result;
47502
47503   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47504   {
47505     try {
47506       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
47507     } CALL_CATCH_EXCEPTION(0);
47508   }
47509
47510   jresult = result;
47511   return jresult;
47512 }
47513
47514
47515 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
47516   unsigned int jresult ;
47517   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47518   bool result;
47519
47520   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47521   {
47522     try {
47523       result = (bool)(arg1)->MoveFocusForward();
47524     } CALL_CATCH_EXCEPTION(0);
47525   }
47526
47527   jresult = result;
47528   return jresult;
47529 }
47530
47531
47532 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
47533   unsigned int jresult ;
47534   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47535   bool result;
47536
47537   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47538   {
47539     try {
47540       result = (bool)(arg1)->MoveFocusBackward();
47541     } CALL_CATCH_EXCEPTION(0);
47542   }
47543
47544   jresult = result;
47545   return jresult;
47546 }
47547
47548
47549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
47550   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47551
47552   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47553   {
47554     try {
47555       (arg1)->ClearFocus();
47556     } CALL_CATCH_EXCEPTION();
47557   }
47558
47559 }
47560
47561
47562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
47563   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47564
47565   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47566   {
47567     try {
47568       (arg1)->Reset();
47569     } CALL_CATCH_EXCEPTION();
47570   }
47571
47572 }
47573
47574
47575 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
47576   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47577   Dali::Actor arg2 ;
47578   bool arg3 ;
47579   Dali::Actor *argp2 ;
47580
47581   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47582   argp2 = (Dali::Actor *)jarg2;
47583   if (!argp2) {
47584     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
47585     return ;
47586   }
47587   arg2 = *argp2;
47588   arg3 = jarg3 ? true : false;
47589   {
47590     try {
47591       (arg1)->SetFocusGroup(arg2,arg3);
47592     } CALL_CATCH_EXCEPTION();
47593   }
47594
47595 }
47596
47597
47598 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
47599   unsigned int jresult ;
47600   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47601   Dali::Actor arg2 ;
47602   Dali::Actor *argp2 ;
47603   bool result;
47604
47605   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47606   argp2 = (Dali::Actor *)jarg2;
47607   if (!argp2) {
47608     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
47609     return 0;
47610   }
47611   arg2 = *argp2;
47612   {
47613     try {
47614       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
47615     } CALL_CATCH_EXCEPTION(0);
47616   }
47617
47618   jresult = result;
47619   return jresult;
47620 }
47621
47622
47623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
47624   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47625   bool arg2 ;
47626
47627   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47628   arg2 = jarg2 ? true : false;
47629   {
47630     try {
47631       (arg1)->SetGroupMode(arg2);
47632     } CALL_CATCH_EXCEPTION();
47633   }
47634
47635 }
47636
47637
47638 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
47639   unsigned int jresult ;
47640   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47641   bool result;
47642
47643   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47644   {
47645     try {
47646       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
47647     } CALL_CATCH_EXCEPTION(0);
47648   }
47649
47650   jresult = result;
47651   return jresult;
47652 }
47653
47654
47655 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
47656   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47657   bool arg2 ;
47658
47659   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47660   arg2 = jarg2 ? true : false;
47661   {
47662     try {
47663       (arg1)->SetWrapMode(arg2);
47664     } CALL_CATCH_EXCEPTION();
47665   }
47666
47667 }
47668
47669
47670 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
47671   unsigned int jresult ;
47672   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47673   bool result;
47674
47675   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47676   {
47677     try {
47678       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
47679     } CALL_CATCH_EXCEPTION(0);
47680   }
47681
47682   jresult = result;
47683   return jresult;
47684 }
47685
47686
47687 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
47688   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47689   Dali::Actor arg2 ;
47690   Dali::Actor *argp2 ;
47691
47692   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47693   argp2 = (Dali::Actor *)jarg2;
47694   if (!argp2) {
47695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
47696     return ;
47697   }
47698   arg2 = *argp2;
47699   {
47700     try {
47701       (arg1)->SetFocusIndicatorActor(arg2);
47702     } CALL_CATCH_EXCEPTION();
47703   }
47704
47705 }
47706
47707
47708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
47709   void * jresult ;
47710   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47711   Dali::Actor result;
47712
47713   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47714   {
47715     try {
47716       result = (arg1)->GetFocusIndicatorActor();
47717     } CALL_CATCH_EXCEPTION(0);
47718   }
47719
47720   jresult = new Dali::Actor((const Dali::Actor &)result);
47721   return jresult;
47722 }
47723
47724
47725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
47726   void * jresult ;
47727   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47728   Dali::Actor arg2 ;
47729   Dali::Actor *argp2 ;
47730   Dali::Actor result;
47731
47732   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47733   argp2 = (Dali::Actor *)jarg2;
47734   if (!argp2) {
47735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
47736     return 0;
47737   }
47738   arg2 = *argp2;
47739   {
47740     try {
47741       result = (arg1)->GetFocusGroup(arg2);
47742     } CALL_CATCH_EXCEPTION(0);
47743   }
47744
47745   jresult = new Dali::Actor((const Dali::Actor &)result);
47746   return jresult;
47747 }
47748
47749
47750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
47751   void * jresult ;
47752   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47753   Dali::Vector2 result;
47754
47755   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47756   {
47757     try {
47758       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
47759     } CALL_CATCH_EXCEPTION(0);
47760   }
47761
47762   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
47763   return jresult;
47764 }
47765
47766
47767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
47768   void * jresult ;
47769   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47770   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
47771
47772   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47773   {
47774     try {
47775       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
47776     } CALL_CATCH_EXCEPTION(0);
47777   }
47778
47779   jresult = (void *)result;
47780   return jresult;
47781 }
47782
47783
47784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
47785   void * jresult ;
47786   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47787   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
47788
47789   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47790   {
47791     try {
47792       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
47793     } CALL_CATCH_EXCEPTION(0);
47794   }
47795
47796   jresult = (void *)result;
47797   return jresult;
47798 }
47799
47800
47801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
47802   void * jresult ;
47803   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47804   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
47805
47806   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47807   {
47808     try {
47809       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
47810     } CALL_CATCH_EXCEPTION(0);
47811   }
47812
47813   jresult = (void *)result;
47814   return jresult;
47815 }
47816
47817
47818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
47819   void * jresult ;
47820   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47821   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
47822
47823   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47824   {
47825     try {
47826       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
47827     } CALL_CATCH_EXCEPTION(0);
47828   }
47829
47830   jresult = (void *)result;
47831   return jresult;
47832 }
47833
47834
47835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
47836   void * jresult ;
47837   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47838   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
47839
47840   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47841   {
47842     try {
47843       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
47844     } CALL_CATCH_EXCEPTION(0);
47845   }
47846
47847   jresult = (void *)result;
47848   return jresult;
47849 }
47850
47851
47852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
47853   void * jresult ;
47854   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47855   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
47856
47857   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47858   {
47859     try {
47860       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
47861     } CALL_CATCH_EXCEPTION(0);
47862   }
47863
47864   jresult = (void *)result;
47865   return jresult;
47866 }
47867
47868
47869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
47870   void * jresult ;
47871   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47872   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
47873
47874   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47875   {
47876     try {
47877       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
47878     } CALL_CATCH_EXCEPTION(0);
47879   }
47880
47881   jresult = (void *)result;
47882   return jresult;
47883 }
47884
47885
47886 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
47887   void * jresult ;
47888   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47889   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
47890
47891   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47892   {
47893     try {
47894       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
47895     } CALL_CATCH_EXCEPTION(0);
47896   }
47897
47898   jresult = (void *)result;
47899   return jresult;
47900 }
47901
47902
47903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
47904   void * jresult ;
47905   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47906   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
47907
47908   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47909   {
47910     try {
47911       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
47912     } CALL_CATCH_EXCEPTION(0);
47913   }
47914
47915   jresult = (void *)result;
47916   return jresult;
47917 }
47918
47919
47920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
47921   void * jresult ;
47922   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47923   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
47924
47925   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47926   {
47927     try {
47928       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
47929     } CALL_CATCH_EXCEPTION(0);
47930   }
47931
47932   jresult = (void *)result;
47933   return jresult;
47934 }
47935
47936
47937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
47938   void * jresult ;
47939   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47940   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
47941
47942   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47943   {
47944     try {
47945       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
47946     } CALL_CATCH_EXCEPTION(0);
47947   }
47948
47949   jresult = (void *)result;
47950   return jresult;
47951 }
47952
47953
47954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
47955   void * jresult ;
47956   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47957   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
47958
47959   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47960   {
47961     try {
47962       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
47963     } CALL_CATCH_EXCEPTION(0);
47964   }
47965
47966   jresult = (void *)result;
47967   return jresult;
47968 }
47969
47970
47971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
47972   void * jresult ;
47973   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47974   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
47975
47976   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47977   {
47978     try {
47979       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
47980     } CALL_CATCH_EXCEPTION(0);
47981   }
47982
47983   jresult = (void *)result;
47984   return jresult;
47985 }
47986
47987
47988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
47989   void * jresult ;
47990   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47991   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
47992
47993   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47994   {
47995     try {
47996       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
47997     } CALL_CATCH_EXCEPTION(0);
47998   }
47999
48000   jresult = (void *)result;
48001   return jresult;
48002 }
48003
48004
48005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
48006   void * jresult ;
48007   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48008   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
48009
48010   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48011   {
48012     try {
48013       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
48014     } CALL_CATCH_EXCEPTION(0);
48015   }
48016
48017   jresult = (void *)result;
48018   return jresult;
48019 }
48020
48021
48022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
48023   void * jresult ;
48024   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48025   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
48026
48027   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48028   {
48029     try {
48030       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
48031     } CALL_CATCH_EXCEPTION(0);
48032   }
48033
48034   jresult = (void *)result;
48035   return jresult;
48036 }
48037
48038
48039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
48040   void * jresult ;
48041   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48042   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
48043
48044   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48045   {
48046     try {
48047       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
48048     } CALL_CATCH_EXCEPTION(0);
48049   }
48050
48051   jresult = (void *)result;
48052   return jresult;
48053 }
48054
48055
48056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
48057   void * jresult ;
48058   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48059   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
48060
48061   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48062   {
48063     try {
48064       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
48065     } CALL_CATCH_EXCEPTION(0);
48066   }
48067
48068   jresult = (void *)result;
48069   return jresult;
48070 }
48071
48072
48073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
48074   void * jresult ;
48075   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48076   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
48077
48078   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48079   {
48080     try {
48081       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
48082     } CALL_CATCH_EXCEPTION(0);
48083   }
48084
48085   jresult = (void *)result;
48086   return jresult;
48087 }
48088
48089
48090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
48091   void * jresult ;
48092   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48093   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
48094
48095   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48096   {
48097     try {
48098       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
48099     } CALL_CATCH_EXCEPTION(0);
48100   }
48101
48102   jresult = (void *)result;
48103   return jresult;
48104 }
48105
48106
48107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
48108   void * jresult ;
48109   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48110   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
48111
48112   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48113   {
48114     try {
48115       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
48116     } CALL_CATCH_EXCEPTION(0);
48117   }
48118
48119   jresult = (void *)result;
48120   return jresult;
48121 }
48122
48123
48124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
48125   void * jresult ;
48126   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48127   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
48128
48129   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48130   {
48131     try {
48132       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
48133     } CALL_CATCH_EXCEPTION(0);
48134   }
48135
48136   jresult = (void *)result;
48137   return jresult;
48138 }
48139
48140
48141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
48142   void * jresult ;
48143   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48144   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
48145
48146   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48147   {
48148     try {
48149       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
48150     } CALL_CATCH_EXCEPTION(0);
48151   }
48152
48153   jresult = (void *)result;
48154   return jresult;
48155 }
48156
48157
48158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
48159   void * jresult ;
48160   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48161   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
48162
48163   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48164   {
48165     try {
48166       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
48167     } CALL_CATCH_EXCEPTION(0);
48168   }
48169
48170   jresult = (void *)result;
48171   return jresult;
48172 }
48173
48174
48175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
48176   void * jresult ;
48177   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48178   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
48179
48180   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48181   {
48182     try {
48183       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
48184     } CALL_CATCH_EXCEPTION(0);
48185   }
48186
48187   jresult = (void *)result;
48188   return jresult;
48189 }
48190
48191
48192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
48193   void * jresult ;
48194   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48195   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
48196
48197   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48198   {
48199     try {
48200       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
48201     } CALL_CATCH_EXCEPTION(0);
48202   }
48203
48204   jresult = (void *)result;
48205   return jresult;
48206 }
48207
48208
48209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
48210   void * jresult ;
48211   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48212   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
48213
48214   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48215   {
48216     try {
48217       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
48218     } CALL_CATCH_EXCEPTION(0);
48219   }
48220
48221   jresult = (void *)result;
48222   return jresult;
48223 }
48224
48225
48226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
48227   void * jresult ;
48228   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48229   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
48230
48231   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48232   {
48233     try {
48234       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
48235     } CALL_CATCH_EXCEPTION(0);
48236   }
48237
48238   jresult = (void *)result;
48239   return jresult;
48240 }
48241
48242
48243 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
48244   void * jresult ;
48245   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48246   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
48247
48248   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48249   {
48250     try {
48251       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
48252     } CALL_CATCH_EXCEPTION(0);
48253   }
48254
48255   jresult = (void *)result;
48256   return jresult;
48257 }
48258
48259
48260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
48261   void * jresult ;
48262   Dali::Toolkit::StyleManager *result = 0 ;
48263
48264   {
48265     try {
48266       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
48267     } CALL_CATCH_EXCEPTION(0);
48268   }
48269
48270   jresult = (void *)result;
48271   return jresult;
48272 }
48273
48274
48275 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
48276   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
48277
48278   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
48279   {
48280     try {
48281       delete arg1;
48282     } CALL_CATCH_EXCEPTION();
48283   }
48284
48285 }
48286
48287
48288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
48289   void * jresult ;
48290   Dali::Toolkit::StyleManager result;
48291
48292   {
48293     try {
48294       result = Dali::Toolkit::StyleManager::Get();
48295     } CALL_CATCH_EXCEPTION(0);
48296   }
48297
48298   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
48299   return jresult;
48300 }
48301
48302
48303 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
48304   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
48305   std::string *arg2 = 0 ;
48306
48307   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
48308   if (!jarg2) {
48309     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
48310     return ;
48311   }
48312   std::string arg2_str(jarg2);
48313   arg2 = &arg2_str;
48314   {
48315     try {
48316       (arg1)->ApplyTheme((std::string const &)*arg2);
48317     } CALL_CATCH_EXCEPTION();
48318   }
48319
48320
48321   //argout typemap for const std::string&
48322
48323 }
48324
48325
48326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
48327   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
48328
48329   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
48330   {
48331     try {
48332       (arg1)->ApplyDefaultTheme();
48333     } CALL_CATCH_EXCEPTION();
48334   }
48335
48336 }
48337
48338
48339 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
48340   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
48341   std::string *arg2 = 0 ;
48342   Dali::Property::Value *arg3 = 0 ;
48343
48344   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
48345   if (!jarg2) {
48346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
48347     return ;
48348   }
48349   std::string arg2_str(jarg2);
48350   arg2 = &arg2_str;
48351   arg3 = (Dali::Property::Value *)jarg3;
48352   if (!arg3) {
48353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
48354     return ;
48355   }
48356   {
48357     try {
48358       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
48359     } CALL_CATCH_EXCEPTION();
48360   }
48361
48362
48363   //argout typemap for const std::string&
48364
48365 }
48366
48367
48368 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
48369   unsigned int jresult ;
48370   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
48371   std::string *arg2 = 0 ;
48372   Dali::Property::Value *arg3 = 0 ;
48373   bool result;
48374
48375   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
48376   if (!jarg2) {
48377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
48378     return 0;
48379   }
48380   std::string arg2_str(jarg2);
48381   arg2 = &arg2_str;
48382   arg3 = (Dali::Property::Value *)jarg3;
48383   if (!arg3) {
48384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
48385     return 0;
48386   }
48387   {
48388     try {
48389       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
48390     } CALL_CATCH_EXCEPTION(0);
48391   }
48392
48393   jresult = result;
48394
48395   //argout typemap for const std::string&
48396
48397   return jresult;
48398 }
48399
48400
48401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
48402   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
48403   Dali::Toolkit::Control arg2 ;
48404   std::string *arg3 = 0 ;
48405   std::string *arg4 = 0 ;
48406   Dali::Toolkit::Control *argp2 ;
48407
48408   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
48409   argp2 = (Dali::Toolkit::Control *)jarg2;
48410   if (!argp2) {
48411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
48412     return ;
48413   }
48414   arg2 = *argp2;
48415   if (!jarg3) {
48416     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
48417     return ;
48418   }
48419   std::string arg3_str(jarg3);
48420   arg3 = &arg3_str;
48421   if (!jarg4) {
48422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
48423     return ;
48424   }
48425   std::string arg4_str(jarg4);
48426   arg4 = &arg4_str;
48427   {
48428     try {
48429       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
48430     } CALL_CATCH_EXCEPTION();
48431   }
48432
48433
48434   //argout typemap for const std::string&
48435
48436
48437   //argout typemap for const std::string&
48438
48439 }
48440
48441
48442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
48443   void * jresult ;
48444   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
48445   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
48446
48447   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
48448   {
48449     try {
48450       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
48451     } CALL_CATCH_EXCEPTION(0);
48452   }
48453
48454   jresult = (void *)result;
48455   return jresult;
48456 }
48457
48458
48459 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
48460   int jresult ;
48461   int result;
48462
48463   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
48464   jresult = (int)result;
48465   return jresult;
48466 }
48467
48468
48469 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
48470   int jresult ;
48471   int result;
48472
48473   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
48474   jresult = (int)result;
48475   return jresult;
48476 }
48477
48478
48479 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
48480   int jresult ;
48481   int result;
48482
48483   result = (int)Dali::Toolkit::Slider::Property::VALUE;
48484   jresult = (int)result;
48485   return jresult;
48486 }
48487
48488
48489 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
48490   int jresult ;
48491   int result;
48492
48493   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
48494   jresult = (int)result;
48495   return jresult;
48496 }
48497
48498
48499 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
48500   int jresult ;
48501   int result;
48502
48503   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
48504   jresult = (int)result;
48505   return jresult;
48506 }
48507
48508
48509 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
48510   int jresult ;
48511   int result;
48512
48513   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
48514   jresult = (int)result;
48515   return jresult;
48516 }
48517
48518
48519 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
48520   int jresult ;
48521   int result;
48522
48523   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
48524   jresult = (int)result;
48525   return jresult;
48526 }
48527
48528
48529 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
48530   int jresult ;
48531   int result;
48532
48533   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
48534   jresult = (int)result;
48535   return jresult;
48536 }
48537
48538
48539 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
48540   int jresult ;
48541   int result;
48542
48543   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
48544   jresult = (int)result;
48545   return jresult;
48546 }
48547
48548
48549 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
48550   int jresult ;
48551   int result;
48552
48553   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
48554   jresult = (int)result;
48555   return jresult;
48556 }
48557
48558
48559 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
48560   int jresult ;
48561   int result;
48562
48563   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
48564   jresult = (int)result;
48565   return jresult;
48566 }
48567
48568
48569 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
48570   int jresult ;
48571   int result;
48572
48573   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
48574   jresult = (int)result;
48575   return jresult;
48576 }
48577
48578
48579 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
48580   int jresult ;
48581   int result;
48582
48583   result = (int)Dali::Toolkit::Slider::Property::MARKS;
48584   jresult = (int)result;
48585   return jresult;
48586 }
48587
48588
48589 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
48590   int jresult ;
48591   int result;
48592
48593   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
48594   jresult = (int)result;
48595   return jresult;
48596 }
48597
48598
48599 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
48600   int jresult ;
48601   int result;
48602
48603   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
48604   jresult = (int)result;
48605   return jresult;
48606 }
48607
48608
48609 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
48610   void * jresult ;
48611   Dali::Toolkit::Slider::Property *result = 0 ;
48612
48613   {
48614     try {
48615       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
48616     } CALL_CATCH_EXCEPTION(0);
48617   }
48618
48619   jresult = (void *)result;
48620   return jresult;
48621 }
48622
48623
48624 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
48625   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
48626
48627   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
48628   {
48629     try {
48630       delete arg1;
48631     } CALL_CATCH_EXCEPTION();
48632   }
48633
48634 }
48635
48636
48637 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
48638   void * jresult ;
48639   Dali::Toolkit::Slider result;
48640
48641   {
48642     try {
48643       result = Dali::Toolkit::Slider::New();
48644     } CALL_CATCH_EXCEPTION(0);
48645   }
48646
48647   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
48648   return jresult;
48649 }
48650
48651
48652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
48653   void * jresult ;
48654   Dali::Toolkit::Slider *result = 0 ;
48655
48656   {
48657     try {
48658       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
48659     } CALL_CATCH_EXCEPTION(0);
48660   }
48661
48662   jresult = (void *)result;
48663   return jresult;
48664 }
48665
48666
48667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
48668   void * jresult ;
48669   Dali::Toolkit::Slider *arg1 = 0 ;
48670   Dali::Toolkit::Slider *result = 0 ;
48671
48672   arg1 = (Dali::Toolkit::Slider *)jarg1;
48673   if (!arg1) {
48674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
48675     return 0;
48676   }
48677   {
48678     try {
48679       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
48680     } CALL_CATCH_EXCEPTION(0);
48681   }
48682
48683   jresult = (void *)result;
48684   return jresult;
48685 }
48686
48687
48688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
48689   void * jresult ;
48690   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
48691   Dali::Toolkit::Slider *arg2 = 0 ;
48692   Dali::Toolkit::Slider *result = 0 ;
48693
48694   arg1 = (Dali::Toolkit::Slider *)jarg1;
48695   arg2 = (Dali::Toolkit::Slider *)jarg2;
48696   if (!arg2) {
48697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
48698     return 0;
48699   }
48700   {
48701     try {
48702       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
48703     } CALL_CATCH_EXCEPTION(0);
48704   }
48705
48706   jresult = (void *)result;
48707   return jresult;
48708 }
48709
48710
48711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
48712   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
48713
48714   arg1 = (Dali::Toolkit::Slider *)jarg1;
48715   {
48716     try {
48717       delete arg1;
48718     } CALL_CATCH_EXCEPTION();
48719   }
48720
48721 }
48722
48723
48724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
48725   void * jresult ;
48726   Dali::BaseHandle arg1 ;
48727   Dali::BaseHandle *argp1 ;
48728   Dali::Toolkit::Slider result;
48729
48730   argp1 = (Dali::BaseHandle *)jarg1;
48731   if (!argp1) {
48732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
48733     return 0;
48734   }
48735   arg1 = *argp1;
48736   {
48737     try {
48738       result = Dali::Toolkit::Slider::DownCast(arg1);
48739     } CALL_CATCH_EXCEPTION(0);
48740   }
48741
48742   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
48743   return jresult;
48744 }
48745
48746
48747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
48748   void * jresult ;
48749   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
48750   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
48751
48752   arg1 = (Dali::Toolkit::Slider *)jarg1;
48753   {
48754     try {
48755       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
48756     } CALL_CATCH_EXCEPTION(0);
48757   }
48758
48759   jresult = (void *)result;
48760   return jresult;
48761 }
48762
48763
48764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
48765   void * jresult ;
48766   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
48767   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
48768
48769   arg1 = (Dali::Toolkit::Slider *)jarg1;
48770   {
48771     try {
48772       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
48773     } CALL_CATCH_EXCEPTION(0);
48774   }
48775
48776   jresult = (void *)result;
48777   return jresult;
48778 }
48779
48780
48781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
48782   void * jresult ;
48783   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
48784   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
48785
48786   arg1 = (Dali::Toolkit::Slider *)jarg1;
48787   {
48788     try {
48789       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
48790     } CALL_CATCH_EXCEPTION(0);
48791   }
48792
48793   jresult = (void *)result;
48794   return jresult;
48795 }
48796
48797
48798 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
48799   int jresult ;
48800   int result;
48801
48802   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
48803   jresult = (int)result;
48804   return jresult;
48805 }
48806
48807
48808 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
48809   int jresult ;
48810   int result;
48811
48812   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
48813   jresult = (int)result;
48814   return jresult;
48815 }
48816
48817
48818 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
48819   int jresult ;
48820   int result;
48821
48822   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
48823   jresult = (int)result;
48824   return jresult;
48825 }
48826
48827
48828 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
48829   int jresult ;
48830   int result;
48831
48832   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
48833   jresult = (int)result;
48834   return jresult;
48835 }
48836
48837
48838 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_UNDERLAY_get() {
48839   int result;
48840
48841   result = (int)Dali::Toolkit::VideoView::Property::UNDERLAY;
48842
48843   return result;
48844 }
48845
48846
48847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
48848   void * jresult ;
48849   Dali::Toolkit::VideoView::Property *result = 0 ;
48850
48851   {
48852     try {
48853       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
48854     } CALL_CATCH_EXCEPTION(0);
48855   }
48856
48857   jresult = (void *)result;
48858   return jresult;
48859 }
48860
48861
48862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
48863   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
48864
48865   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
48866   {
48867     try {
48868       delete arg1;
48869     } CALL_CATCH_EXCEPTION();
48870   }
48871
48872 }
48873
48874
48875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
48876   void * jresult ;
48877   Dali::Toolkit::VideoView result;
48878
48879   {
48880     try {
48881       result = Dali::Toolkit::VideoView::New();
48882     } CALL_CATCH_EXCEPTION(0);
48883   }
48884
48885   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
48886   return jresult;
48887 }
48888
48889
48890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
48891   void * jresult ;
48892   std::string *arg1 = 0 ;
48893   Dali::Toolkit::VideoView result;
48894
48895   if (!jarg1) {
48896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
48897     return 0;
48898   }
48899   std::string arg1_str(jarg1);
48900   arg1 = &arg1_str;
48901   {
48902     try {
48903       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
48904     } CALL_CATCH_EXCEPTION(0);
48905   }
48906
48907   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
48908
48909   //argout typemap for const std::string&
48910
48911   return jresult;
48912 }
48913
48914
48915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_2(bool swCodec) {
48916   void * jresult ;
48917   Dali::Toolkit::VideoView result;
48918   {
48919     try {
48920       result = Dali::Toolkit::VideoView::New(swCodec);
48921     } CALL_CATCH_EXCEPTION(0);
48922   }
48923
48924   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
48925
48926   //argout typemap for const std::string&
48927
48928   return jresult;
48929 }
48930
48931
48932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_3(char * jarg1, bool swCodec) {
48933   void * jresult ;
48934   std::string *arg1 = 0 ;
48935   Dali::Toolkit::VideoView result;
48936
48937   if (!jarg1) {
48938     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
48939     return 0;
48940   }
48941   std::string arg1_str(jarg1);
48942   arg1 = &arg1_str;
48943   {
48944     try {
48945       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1, swCodec);
48946     } CALL_CATCH_EXCEPTION(0);
48947   }
48948
48949   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
48950
48951   //argout typemap for const std::string&
48952
48953   return jresult;
48954 }
48955
48956
48957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
48958   void * jresult ;
48959   Dali::Toolkit::VideoView *result = 0 ;
48960
48961   {
48962     try {
48963       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
48964     } CALL_CATCH_EXCEPTION(0);
48965   }
48966
48967   jresult = (void *)result;
48968   return jresult;
48969 }
48970
48971
48972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
48973   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
48974
48975   arg1 = (Dali::Toolkit::VideoView *)jarg1;
48976   {
48977     try {
48978       delete arg1;
48979     } CALL_CATCH_EXCEPTION();
48980   }
48981
48982 }
48983
48984
48985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
48986   void * jresult ;
48987   Dali::Toolkit::VideoView *arg1 = 0 ;
48988   Dali::Toolkit::VideoView *result = 0 ;
48989
48990   arg1 = (Dali::Toolkit::VideoView *)jarg1;
48991   if (!arg1) {
48992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
48993     return 0;
48994   }
48995   {
48996     try {
48997       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
48998     } CALL_CATCH_EXCEPTION(0);
48999   }
49000
49001   jresult = (void *)result;
49002   return jresult;
49003 }
49004
49005
49006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
49007   void * jresult ;
49008   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
49009   Dali::Toolkit::VideoView *arg2 = 0 ;
49010   Dali::Toolkit::VideoView *result = 0 ;
49011
49012   arg1 = (Dali::Toolkit::VideoView *)jarg1;
49013   arg2 = (Dali::Toolkit::VideoView *)jarg2;
49014   if (!arg2) {
49015     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
49016     return 0;
49017   }
49018   {
49019     try {
49020       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
49021     } CALL_CATCH_EXCEPTION(0);
49022   }
49023
49024   jresult = (void *)result;
49025   return jresult;
49026 }
49027
49028
49029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
49030   void * jresult ;
49031   Dali::BaseHandle arg1 ;
49032   Dali::BaseHandle *argp1 ;
49033   Dali::Toolkit::VideoView result;
49034
49035   argp1 = (Dali::BaseHandle *)jarg1;
49036   if (!argp1) {
49037     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
49038     return 0;
49039   }
49040   arg1 = *argp1;
49041   {
49042     try {
49043       result = Dali::Toolkit::VideoView::DownCast(arg1);
49044     } CALL_CATCH_EXCEPTION(0);
49045   }
49046
49047   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
49048   return jresult;
49049 }
49050
49051
49052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
49053   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
49054
49055   arg1 = (Dali::Toolkit::VideoView *)jarg1;
49056   {
49057     try {
49058       (arg1)->Play();
49059     } CALL_CATCH_EXCEPTION();
49060   }
49061
49062 }
49063
49064
49065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
49066   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
49067
49068   arg1 = (Dali::Toolkit::VideoView *)jarg1;
49069   {
49070     try {
49071       (arg1)->Pause();
49072     } CALL_CATCH_EXCEPTION();
49073   }
49074
49075 }
49076
49077
49078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
49079   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
49080
49081   arg1 = (Dali::Toolkit::VideoView *)jarg1;
49082   {
49083     try {
49084       (arg1)->Stop();
49085     } CALL_CATCH_EXCEPTION();
49086   }
49087
49088 }
49089
49090
49091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
49092   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
49093   int arg2 ;
49094
49095   arg1 = (Dali::Toolkit::VideoView *)jarg1;
49096   arg2 = (int)jarg2;
49097   {
49098     try {
49099       (arg1)->Forward(arg2);
49100     } CALL_CATCH_EXCEPTION();
49101   }
49102
49103 }
49104
49105
49106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
49107   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
49108   int arg2 ;
49109
49110   arg1 = (Dali::Toolkit::VideoView *)jarg1;
49111   arg2 = (int)jarg2;
49112   {
49113     try {
49114       (arg1)->Backward(arg2);
49115     } CALL_CATCH_EXCEPTION();
49116   }
49117
49118 }
49119
49120
49121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
49122   void * jresult ;
49123   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
49124   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
49125
49126   arg1 = (Dali::Toolkit::VideoView *)jarg1;
49127   {
49128     try {
49129       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
49130     } CALL_CATCH_EXCEPTION(0);
49131   }
49132
49133   jresult = (void *)result;
49134   return jresult;
49135 }
49136
49137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_GetNativePlayerHandle( void * jarg1 )
49138 {
49139   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *)jarg1;
49140   if( arg1 == nullptr )
49141   {
49142     DALI_LOG_ERROR("VideoView is nullptr!");
49143     return nullptr;
49144   }
49145   void * ret = nullptr;
49146   {
49147     try{
49148
49149       Dali::Any result = Toolkit::DevelVideoView::GetMediaPlayer( *arg1 );
49150       ret = Dali::AnyCast< void * >( result );
49151
49152     } CALL_CATCH_EXCEPTION(0);
49153   }
49154   return ret;
49155 }
49156
49157
49158 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
49159   int jresult ;
49160   int result;
49161
49162   result = (int)Dali::Toolkit::Popup::Property::TITLE;
49163   jresult = (int)result;
49164   return jresult;
49165 }
49166
49167
49168 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
49169   int jresult ;
49170   int result;
49171
49172   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
49173   jresult = (int)result;
49174   return jresult;
49175 }
49176
49177
49178 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
49179   int jresult ;
49180   int result;
49181
49182   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
49183   jresult = (int)result;
49184   return jresult;
49185 }
49186
49187
49188 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
49189   int jresult ;
49190   int result;
49191
49192   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
49193   jresult = (int)result;
49194   return jresult;
49195 }
49196
49197
49198 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
49199   int jresult ;
49200   int result;
49201
49202   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
49203   jresult = (int)result;
49204   return jresult;
49205 }
49206
49207
49208 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
49209   int jresult ;
49210   int result;
49211
49212   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
49213   jresult = (int)result;
49214   return jresult;
49215 }
49216
49217
49218 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
49219   int jresult ;
49220   int result;
49221
49222   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
49223   jresult = (int)result;
49224   return jresult;
49225 }
49226
49227
49228 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
49229   int jresult ;
49230   int result;
49231
49232   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
49233   jresult = (int)result;
49234   return jresult;
49235 }
49236
49237
49238 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
49239   int jresult ;
49240   int result;
49241
49242   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
49243   jresult = (int)result;
49244   return jresult;
49245 }
49246
49247
49248 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
49249   int jresult ;
49250   int result;
49251
49252   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
49253   jresult = (int)result;
49254   return jresult;
49255 }
49256
49257
49258 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
49259   int jresult ;
49260   int result;
49261
49262   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
49263   jresult = (int)result;
49264   return jresult;
49265 }
49266
49267
49268 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
49269   int jresult ;
49270   int result;
49271
49272   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
49273   jresult = (int)result;
49274   return jresult;
49275 }
49276
49277
49278 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
49279   int jresult ;
49280   int result;
49281
49282   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
49283   jresult = (int)result;
49284   return jresult;
49285 }
49286
49287
49288 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
49289   int jresult ;
49290   int result;
49291
49292   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
49293   jresult = (int)result;
49294   return jresult;
49295 }
49296
49297
49298 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
49299   int jresult ;
49300   int result;
49301
49302   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
49303   jresult = (int)result;
49304   return jresult;
49305 }
49306
49307
49308 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
49309   int jresult ;
49310   int result;
49311
49312   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
49313   jresult = (int)result;
49314   return jresult;
49315 }
49316
49317
49318 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
49319   int jresult ;
49320   int result;
49321
49322   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
49323   jresult = (int)result;
49324   return jresult;
49325 }
49326
49327
49328 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
49329   int jresult ;
49330   int result;
49331
49332   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
49333   jresult = (int)result;
49334   return jresult;
49335 }
49336
49337
49338 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
49339   int jresult ;
49340   int result;
49341
49342   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
49343   jresult = (int)result;
49344   return jresult;
49345 }
49346
49347
49348 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
49349   int jresult ;
49350   int result;
49351
49352   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
49353   jresult = (int)result;
49354   return jresult;
49355 }
49356
49357
49358 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
49359   int jresult ;
49360   int result;
49361
49362   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
49363   jresult = (int)result;
49364   return jresult;
49365 }
49366
49367
49368 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
49369   void * jresult ;
49370   Dali::Toolkit::Popup::Property *result = 0 ;
49371
49372   {
49373     try {
49374       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
49375     } CALL_CATCH_EXCEPTION(0);
49376   }
49377
49378   jresult = (void *)result;
49379   return jresult;
49380 }
49381
49382
49383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
49384   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
49385
49386   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
49387   {
49388     try {
49389       delete arg1;
49390     } CALL_CATCH_EXCEPTION();
49391   }
49392
49393 }
49394
49395
49396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
49397   void * jresult ;
49398   Dali::Toolkit::Popup *result = 0 ;
49399
49400   {
49401     try {
49402       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
49403     } CALL_CATCH_EXCEPTION(0);
49404   }
49405
49406   jresult = (void *)result;
49407   return jresult;
49408 }
49409
49410
49411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
49412   void * jresult ;
49413   Dali::Toolkit::Popup result;
49414
49415   {
49416     try {
49417       result = Dali::Toolkit::Popup::New();
49418     } CALL_CATCH_EXCEPTION(0);
49419   }
49420
49421   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
49422   return jresult;
49423 }
49424
49425
49426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
49427   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
49428
49429   arg1 = (Dali::Toolkit::Popup *)jarg1;
49430   {
49431     try {
49432       delete arg1;
49433     } CALL_CATCH_EXCEPTION();
49434   }
49435
49436 }
49437
49438
49439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
49440   void * jresult ;
49441   Dali::Toolkit::Popup *arg1 = 0 ;
49442   Dali::Toolkit::Popup *result = 0 ;
49443
49444   arg1 = (Dali::Toolkit::Popup *)jarg1;
49445   if (!arg1) {
49446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
49447     return 0;
49448   }
49449   {
49450     try {
49451       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
49452     } CALL_CATCH_EXCEPTION(0);
49453   }
49454
49455   jresult = (void *)result;
49456   return jresult;
49457 }
49458
49459
49460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
49461   void * jresult ;
49462   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
49463   Dali::Toolkit::Popup *arg2 = 0 ;
49464   Dali::Toolkit::Popup *result = 0 ;
49465
49466   arg1 = (Dali::Toolkit::Popup *)jarg1;
49467   arg2 = (Dali::Toolkit::Popup *)jarg2;
49468   if (!arg2) {
49469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
49470     return 0;
49471   }
49472   {
49473     try {
49474       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
49475     } CALL_CATCH_EXCEPTION(0);
49476   }
49477
49478   jresult = (void *)result;
49479   return jresult;
49480 }
49481
49482
49483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
49484   void * jresult ;
49485   Dali::BaseHandle arg1 ;
49486   Dali::BaseHandle *argp1 ;
49487   Dali::Toolkit::Popup result;
49488
49489   argp1 = (Dali::BaseHandle *)jarg1;
49490   if (!argp1) {
49491     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
49492     return 0;
49493   }
49494   arg1 = *argp1;
49495   {
49496     try {
49497       result = Dali::Toolkit::Popup::DownCast(arg1);
49498     } CALL_CATCH_EXCEPTION(0);
49499   }
49500
49501   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
49502   return jresult;
49503 }
49504
49505
49506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
49507   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
49508   Dali::Actor arg2 ;
49509   Dali::Actor *argp2 ;
49510
49511   arg1 = (Dali::Toolkit::Popup *)jarg1;
49512   argp2 = (Dali::Actor *)jarg2;
49513   if (!argp2) {
49514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
49515     return ;
49516   }
49517   arg2 = *argp2;
49518   {
49519     try {
49520       (arg1)->SetTitle(arg2);
49521     } CALL_CATCH_EXCEPTION();
49522   }
49523
49524 }
49525
49526
49527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
49528   void * jresult ;
49529   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
49530   Dali::Actor result;
49531
49532   arg1 = (Dali::Toolkit::Popup *)jarg1;
49533   {
49534     try {
49535       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
49536     } CALL_CATCH_EXCEPTION(0);
49537   }
49538
49539   jresult = new Dali::Actor((const Dali::Actor &)result);
49540   return jresult;
49541 }
49542
49543
49544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
49545   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
49546   Dali::Actor arg2 ;
49547   Dali::Actor *argp2 ;
49548
49549   arg1 = (Dali::Toolkit::Popup *)jarg1;
49550   argp2 = (Dali::Actor *)jarg2;
49551   if (!argp2) {
49552     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
49553     return ;
49554   }
49555   arg2 = *argp2;
49556   {
49557     try {
49558       (arg1)->SetContent(arg2);
49559     } CALL_CATCH_EXCEPTION();
49560   }
49561
49562 }
49563
49564
49565 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
49566   void * jresult ;
49567   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
49568   Dali::Actor result;
49569
49570   arg1 = (Dali::Toolkit::Popup *)jarg1;
49571   {
49572     try {
49573       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
49574     } CALL_CATCH_EXCEPTION(0);
49575   }
49576
49577   jresult = new Dali::Actor((const Dali::Actor &)result);
49578   return jresult;
49579 }
49580
49581
49582 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
49583   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
49584   Dali::Actor arg2 ;
49585   Dali::Actor *argp2 ;
49586
49587   arg1 = (Dali::Toolkit::Popup *)jarg1;
49588   argp2 = (Dali::Actor *)jarg2;
49589   if (!argp2) {
49590     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
49591     return ;
49592   }
49593   arg2 = *argp2;
49594   {
49595     try {
49596       (arg1)->SetFooter(arg2);
49597     } CALL_CATCH_EXCEPTION();
49598   }
49599
49600 }
49601
49602
49603 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
49604   void * jresult ;
49605   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
49606   Dali::Actor result;
49607
49608   arg1 = (Dali::Toolkit::Popup *)jarg1;
49609   {
49610     try {
49611       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
49612     } CALL_CATCH_EXCEPTION(0);
49613   }
49614
49615   jresult = new Dali::Actor((const Dali::Actor &)result);
49616   return jresult;
49617 }
49618
49619
49620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
49621   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
49622   Dali::Toolkit::Popup::DisplayState arg2 ;
49623
49624   arg1 = (Dali::Toolkit::Popup *)jarg1;
49625   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
49626   {
49627     try {
49628       (arg1)->SetDisplayState(arg2);
49629     } CALL_CATCH_EXCEPTION();
49630   }
49631
49632 }
49633
49634
49635 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
49636   int jresult ;
49637   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
49638   Dali::Toolkit::Popup::DisplayState result;
49639
49640   arg1 = (Dali::Toolkit::Popup *)jarg1;
49641   {
49642     try {
49643       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
49644     } CALL_CATCH_EXCEPTION(0);
49645   }
49646
49647   jresult = (int)result;
49648   return jresult;
49649 }
49650
49651
49652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
49653   void * jresult ;
49654   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
49655   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
49656
49657   arg1 = (Dali::Toolkit::Popup *)jarg1;
49658   {
49659     try {
49660       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
49661     } CALL_CATCH_EXCEPTION(0);
49662   }
49663
49664   jresult = (void *)result;
49665   return jresult;
49666 }
49667
49668
49669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
49670   void * jresult ;
49671   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
49672   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
49673
49674   arg1 = (Dali::Toolkit::Popup *)jarg1;
49675   {
49676     try {
49677       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
49678     } CALL_CATCH_EXCEPTION(0);
49679   }
49680
49681   jresult = (void *)result;
49682   return jresult;
49683 }
49684
49685
49686 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
49687   void * jresult ;
49688   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
49689   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
49690
49691   arg1 = (Dali::Toolkit::Popup *)jarg1;
49692   {
49693     try {
49694       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
49695     } CALL_CATCH_EXCEPTION(0);
49696   }
49697
49698   jresult = (void *)result;
49699   return jresult;
49700 }
49701
49702
49703 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
49704   void * jresult ;
49705   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
49706   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
49707
49708   arg1 = (Dali::Toolkit::Popup *)jarg1;
49709   {
49710     try {
49711       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
49712     } CALL_CATCH_EXCEPTION(0);
49713   }
49714
49715   jresult = (void *)result;
49716   return jresult;
49717 }
49718
49719
49720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
49721   void * jresult ;
49722   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
49723   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
49724
49725   arg1 = (Dali::Toolkit::Popup *)jarg1;
49726   {
49727     try {
49728       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
49729     } CALL_CATCH_EXCEPTION(0);
49730   }
49731
49732   jresult = (void *)result;
49733   return jresult;
49734 }
49735
49736
49737 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
49738   int jresult ;
49739   int result;
49740
49741   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
49742   jresult = (int)result;
49743   return jresult;
49744 }
49745
49746
49747 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
49748   int jresult ;
49749   int result;
49750
49751   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
49752   jresult = (int)result;
49753   return jresult;
49754 }
49755
49756
49757 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
49758   int jresult ;
49759   int result;
49760
49761   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
49762   jresult = (int)result;
49763   return jresult;
49764 }
49765
49766
49767 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
49768   int jresult ;
49769   int result;
49770
49771   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
49772   jresult = (int)result;
49773   return jresult;
49774 }
49775
49776
49777 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
49778   int jresult ;
49779   int result;
49780
49781   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
49782   jresult = (int)result;
49783   return jresult;
49784 }
49785
49786
49787 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
49788   int jresult ;
49789   int result;
49790
49791   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
49792   jresult = (int)result;
49793   return jresult;
49794 }
49795
49796
49797 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
49798   int jresult ;
49799   int result;
49800
49801   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
49802   jresult = (int)result;
49803   return jresult;
49804 }
49805
49806
49807 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
49808   int jresult ;
49809   int result;
49810
49811   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
49812   jresult = (int)result;
49813   return jresult;
49814 }
49815
49816
49817 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
49818   int jresult ;
49819   int result;
49820
49821   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
49822   jresult = (int)result;
49823   return jresult;
49824 }
49825
49826
49827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
49828   void * jresult ;
49829   Dali::Toolkit::ProgressBar::Property *result = 0 ;
49830
49831   {
49832     try {
49833       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
49834     } CALL_CATCH_EXCEPTION(0);
49835   }
49836
49837   jresult = (void *)result;
49838   return jresult;
49839 }
49840
49841
49842 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
49843   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
49844
49845   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
49846   {
49847     try {
49848       delete arg1;
49849     } CALL_CATCH_EXCEPTION();
49850   }
49851
49852 }
49853
49854
49855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
49856   void * jresult ;
49857   Dali::Toolkit::ProgressBar result;
49858
49859   {
49860     try {
49861       result = Dali::Toolkit::ProgressBar::New();
49862     } CALL_CATCH_EXCEPTION(0);
49863   }
49864
49865   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
49866   return jresult;
49867 }
49868
49869
49870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
49871   void * jresult ;
49872   Dali::Toolkit::ProgressBar *result = 0 ;
49873
49874   {
49875     try {
49876       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
49877     } CALL_CATCH_EXCEPTION(0);
49878   }
49879
49880   jresult = (void *)result;
49881   return jresult;
49882 }
49883
49884
49885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
49886   void * jresult ;
49887   Dali::Toolkit::ProgressBar *arg1 = 0 ;
49888   Dali::Toolkit::ProgressBar *result = 0 ;
49889
49890   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
49891   if (!arg1) {
49892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
49893     return 0;
49894   }
49895   {
49896     try {
49897       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
49898     } CALL_CATCH_EXCEPTION(0);
49899   }
49900
49901   jresult = (void *)result;
49902   return jresult;
49903 }
49904
49905
49906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
49907   void * jresult ;
49908   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
49909   Dali::Toolkit::ProgressBar *arg2 = 0 ;
49910   Dali::Toolkit::ProgressBar *result = 0 ;
49911
49912   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
49913   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
49914   if (!arg2) {
49915     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
49916     return 0;
49917   }
49918   {
49919     try {
49920       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
49921     } CALL_CATCH_EXCEPTION(0);
49922   }
49923
49924   jresult = (void *)result;
49925   return jresult;
49926 }
49927
49928
49929 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
49930   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
49931
49932   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
49933   {
49934     try {
49935       delete arg1;
49936     } CALL_CATCH_EXCEPTION();
49937   }
49938
49939 }
49940
49941
49942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
49943   void * jresult ;
49944   Dali::BaseHandle arg1 ;
49945   Dali::BaseHandle *argp1 ;
49946   Dali::Toolkit::ProgressBar result;
49947
49948   argp1 = (Dali::BaseHandle *)jarg1;
49949   if (!argp1) {
49950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
49951     return 0;
49952   }
49953   arg1 = *argp1;
49954   {
49955     try {
49956       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
49957     } CALL_CATCH_EXCEPTION(0);
49958   }
49959
49960   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
49961   return jresult;
49962 }
49963
49964
49965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
49966   void * jresult ;
49967   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
49968   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
49969
49970   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
49971   {
49972     try {
49973       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
49974     } CALL_CATCH_EXCEPTION(0);
49975   }
49976
49977   jresult = (void *)result;
49978   return jresult;
49979 }
49980
49981
49982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
49983   void * jresult ;
49984   Dali::Toolkit::GaussianBlurView *result = 0 ;
49985
49986   {
49987     try {
49988       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
49989     } CALL_CATCH_EXCEPTION(0);
49990   }
49991
49992   jresult = (void *)result;
49993   return jresult;
49994 }
49995
49996
49997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
49998   void * jresult ;
49999   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
50000   Dali::Toolkit::GaussianBlurView *result = 0 ;
50001
50002   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
50003   if (!arg1) {
50004     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
50005     return 0;
50006   }
50007   {
50008     try {
50009       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
50010     } CALL_CATCH_EXCEPTION(0);
50011   }
50012
50013   jresult = (void *)result;
50014   return jresult;
50015 }
50016
50017
50018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
50019   void * jresult ;
50020   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
50021   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
50022   Dali::Toolkit::GaussianBlurView *result = 0 ;
50023
50024   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
50025   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
50026   if (!arg2) {
50027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
50028     return 0;
50029   }
50030   {
50031     try {
50032       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
50033     } CALL_CATCH_EXCEPTION(0);
50034   }
50035
50036   jresult = (void *)result;
50037   return jresult;
50038 }
50039
50040
50041 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
50042   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
50043
50044   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
50045   {
50046     try {
50047       delete arg1;
50048     } CALL_CATCH_EXCEPTION();
50049   }
50050
50051 }
50052
50053
50054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
50055   void * jresult ;
50056   Dali::BaseHandle arg1 ;
50057   Dali::BaseHandle *argp1 ;
50058   Dali::Toolkit::GaussianBlurView result;
50059
50060   argp1 = (Dali::BaseHandle *)jarg1;
50061   if (!argp1) {
50062     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
50063     return 0;
50064   }
50065   arg1 = *argp1;
50066   {
50067     try {
50068       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
50069     } CALL_CATCH_EXCEPTION(0);
50070   }
50071
50072   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
50073   return jresult;
50074 }
50075
50076
50077 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
50078   void * jresult ;
50079   Dali::Toolkit::GaussianBlurView result;
50080
50081   {
50082     try {
50083       result = Dali::Toolkit::GaussianBlurView::New();
50084     } CALL_CATCH_EXCEPTION(0);
50085   }
50086
50087   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
50088   return jresult;
50089 }
50090
50091
50092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
50093   void * jresult ;
50094   unsigned int arg1 ;
50095   float arg2 ;
50096   Dali::Pixel::Format arg3 ;
50097   float arg4 ;
50098   float arg5 ;
50099   bool arg6 ;
50100   Dali::Toolkit::GaussianBlurView result;
50101
50102   arg1 = (unsigned int)jarg1;
50103   arg2 = (float)jarg2;
50104   arg3 = (Dali::Pixel::Format)jarg3;
50105   arg4 = (float)jarg4;
50106   arg5 = (float)jarg5;
50107   arg6 = jarg6 ? true : false;
50108   {
50109     try {
50110       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
50111     } CALL_CATCH_EXCEPTION(0);
50112   }
50113
50114   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
50115   return jresult;
50116 }
50117
50118
50119 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
50120   void * jresult ;
50121   unsigned int arg1 ;
50122   float arg2 ;
50123   Dali::Pixel::Format arg3 ;
50124   float arg4 ;
50125   float arg5 ;
50126   Dali::Toolkit::GaussianBlurView result;
50127
50128   arg1 = (unsigned int)jarg1;
50129   arg2 = (float)jarg2;
50130   arg3 = (Dali::Pixel::Format)jarg3;
50131   arg4 = (float)jarg4;
50132   arg5 = (float)jarg5;
50133   {
50134     try {
50135       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
50136     } CALL_CATCH_EXCEPTION(0);
50137   }
50138
50139   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
50140   return jresult;
50141 }
50142
50143
50144 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
50145   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
50146   Dali::Actor arg2 ;
50147   Dali::Actor *argp2 ;
50148
50149   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
50150   argp2 = (Dali::Actor *)jarg2;
50151   if (!argp2) {
50152     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50153     return ;
50154   }
50155   arg2 = *argp2;
50156   {
50157     try {
50158       (arg1)->Add(arg2);
50159     } CALL_CATCH_EXCEPTION();
50160   }
50161
50162 }
50163
50164
50165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
50166   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
50167   Dali::Actor arg2 ;
50168   Dali::Actor *argp2 ;
50169
50170   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
50171   argp2 = (Dali::Actor *)jarg2;
50172   if (!argp2) {
50173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50174     return ;
50175   }
50176   arg2 = *argp2;
50177   {
50178     try {
50179       (arg1)->Remove(arg2);
50180     } CALL_CATCH_EXCEPTION();
50181   }
50182
50183 }
50184
50185
50186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
50187   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
50188
50189   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
50190   {
50191     try {
50192       (arg1)->Activate();
50193     } CALL_CATCH_EXCEPTION();
50194   }
50195
50196 }
50197
50198
50199 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
50200   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
50201
50202   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
50203   {
50204     try {
50205       (arg1)->ActivateOnce();
50206     } CALL_CATCH_EXCEPTION();
50207   }
50208
50209 }
50210
50211
50212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
50213   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
50214
50215   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
50216   {
50217     try {
50218       (arg1)->Deactivate();
50219     } CALL_CATCH_EXCEPTION();
50220   }
50221
50222 }
50223
50224
50225 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
50226   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
50227   Dali::Texture arg2 ;
50228   Dali::FrameBuffer arg3 ;
50229   Dali::Texture *argp2 ;
50230   Dali::FrameBuffer *argp3 ;
50231
50232   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
50233   argp2 = (Dali::Texture *)jarg2;
50234   if (!argp2) {
50235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
50236     return ;
50237   }
50238   arg2 = *argp2;
50239   argp3 = (Dali::FrameBuffer *)jarg3;
50240   if (!argp3) {
50241     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
50242     return ;
50243   }
50244   arg3 = *argp3;
50245   {
50246     try {
50247       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
50248     } CALL_CATCH_EXCEPTION();
50249   }
50250
50251 }
50252
50253
50254 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
50255   int jresult ;
50256   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
50257   Dali::Property::Index result;
50258
50259   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
50260   {
50261     try {
50262       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
50263     } CALL_CATCH_EXCEPTION(0);
50264   }
50265
50266   jresult = result;
50267   return jresult;
50268 }
50269
50270
50271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
50272   void * jresult ;
50273   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
50274   Dali::FrameBuffer result;
50275
50276   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
50277   {
50278     try {
50279       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
50280     } CALL_CATCH_EXCEPTION(0);
50281   }
50282
50283   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
50284   return jresult;
50285 }
50286
50287
50288 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
50289   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
50290   Dali::Vector4 *arg2 = 0 ;
50291
50292   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
50293   arg2 = (Dali::Vector4 *)jarg2;
50294   if (!arg2) {
50295     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
50296     return ;
50297   }
50298   {
50299     try {
50300       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
50301     } CALL_CATCH_EXCEPTION();
50302   }
50303
50304 }
50305
50306
50307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
50308   void * jresult ;
50309   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
50310   Dali::Vector4 result;
50311
50312   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
50313   {
50314     try {
50315       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
50316     } CALL_CATCH_EXCEPTION(0);
50317   }
50318
50319   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
50320   return jresult;
50321 }
50322
50323
50324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
50325   void * jresult ;
50326   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
50327   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
50328
50329   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
50330   {
50331     try {
50332       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
50333     } CALL_CATCH_EXCEPTION(0);
50334   }
50335
50336   jresult = (void *)result;
50337   return jresult;
50338 }
50339
50340
50341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
50342   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
50343
50344   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
50345   {
50346     try {
50347       delete arg1;
50348     } CALL_CATCH_EXCEPTION();
50349   }
50350
50351 }
50352
50353
50354 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
50355   unsigned int jresult ;
50356   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
50357   unsigned int result;
50358
50359   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
50360   {
50361     try {
50362       result = (unsigned int)(arg1)->GetNumberOfPages();
50363     } CALL_CATCH_EXCEPTION(0);
50364   }
50365
50366   jresult = result;
50367   return jresult;
50368 }
50369
50370
50371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
50372   void * jresult ;
50373   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
50374   unsigned int arg2 ;
50375   Dali::Texture result;
50376
50377   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
50378   arg2 = (unsigned int)jarg2;
50379   {
50380     try {
50381       result = (arg1)->NewPage(arg2);
50382     } CALL_CATCH_EXCEPTION(0);
50383   }
50384
50385   jresult = new Dali::Texture((const Dali::Texture &)result);
50386   return jresult;
50387 }
50388
50389
50390 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_VIEW_PAGE_SIZE_get() {
50391   int jresult ;
50392   int result;
50393
50394   result = (int)Dali::Toolkit::PageTurnView::Property::VIEW_PAGE_SIZE;
50395   jresult = (int)result;
50396   return jresult;
50397 }
50398
50399
50400 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
50401   int jresult ;
50402   int result;
50403
50404   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
50405   jresult = (int)result;
50406   return jresult;
50407 }
50408
50409
50410 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
50411   int jresult ;
50412   int result;
50413
50414   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
50415   jresult = (int)result;
50416   return jresult;
50417 }
50418
50419
50420 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
50421   void * jresult ;
50422   Dali::Toolkit::PageTurnView::Property *result = 0 ;
50423
50424   {
50425     try {
50426       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
50427     } CALL_CATCH_EXCEPTION(0);
50428   }
50429
50430   jresult = (void *)result;
50431   return jresult;
50432 }
50433
50434
50435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
50436   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
50437
50438   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
50439   {
50440     try {
50441       delete arg1;
50442     } CALL_CATCH_EXCEPTION();
50443   }
50444
50445 }
50446
50447
50448 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
50449   void * jresult ;
50450   Dali::Toolkit::PageTurnView *result = 0 ;
50451
50452   {
50453     try {
50454       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
50455     } CALL_CATCH_EXCEPTION(0);
50456   }
50457
50458   jresult = (void *)result;
50459   return jresult;
50460 }
50461
50462
50463 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
50464   void * jresult ;
50465   Dali::Toolkit::PageTurnView *arg1 = 0 ;
50466   Dali::Toolkit::PageTurnView *result = 0 ;
50467
50468   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
50469   if (!arg1) {
50470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
50471     return 0;
50472   }
50473   {
50474     try {
50475       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
50476     } CALL_CATCH_EXCEPTION(0);
50477   }
50478
50479   jresult = (void *)result;
50480   return jresult;
50481 }
50482
50483
50484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
50485   void * jresult ;
50486   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
50487   Dali::Toolkit::PageTurnView *arg2 = 0 ;
50488   Dali::Toolkit::PageTurnView *result = 0 ;
50489
50490   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
50491   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
50492   if (!arg2) {
50493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
50494     return 0;
50495   }
50496   {
50497     try {
50498       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
50499     } CALL_CATCH_EXCEPTION(0);
50500   }
50501
50502   jresult = (void *)result;
50503   return jresult;
50504 }
50505
50506
50507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
50508   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
50509
50510   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
50511   {
50512     try {
50513       delete arg1;
50514     } CALL_CATCH_EXCEPTION();
50515   }
50516
50517 }
50518
50519
50520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
50521   void * jresult ;
50522   Dali::BaseHandle arg1 ;
50523   Dali::BaseHandle *argp1 ;
50524   Dali::Toolkit::PageTurnView result;
50525
50526   argp1 = (Dali::BaseHandle *)jarg1;
50527   if (!argp1) {
50528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
50529     return 0;
50530   }
50531   arg1 = *argp1;
50532   {
50533     try {
50534       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
50535     } CALL_CATCH_EXCEPTION(0);
50536   }
50537
50538   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
50539   return jresult;
50540 }
50541
50542
50543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
50544   void * jresult ;
50545   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
50546   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
50547
50548   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
50549   {
50550     try {
50551       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
50552     } CALL_CATCH_EXCEPTION(0);
50553   }
50554
50555   jresult = (void *)result;
50556   return jresult;
50557 }
50558
50559
50560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
50561   void * jresult ;
50562   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
50563   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
50564
50565   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
50566   {
50567     try {
50568       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
50569     } CALL_CATCH_EXCEPTION(0);
50570   }
50571
50572   jresult = (void *)result;
50573   return jresult;
50574 }
50575
50576
50577 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
50578   void * jresult ;
50579   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
50580   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
50581
50582   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
50583   {
50584     try {
50585       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
50586     } CALL_CATCH_EXCEPTION(0);
50587   }
50588
50589   jresult = (void *)result;
50590   return jresult;
50591 }
50592
50593
50594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
50595   void * jresult ;
50596   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
50597   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
50598
50599   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
50600   {
50601     try {
50602       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
50603     } CALL_CATCH_EXCEPTION(0);
50604   }
50605
50606   jresult = (void *)result;
50607   return jresult;
50608 }
50609
50610
50611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
50612   void * jresult ;
50613   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
50614
50615   {
50616     try {
50617       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
50618     } CALL_CATCH_EXCEPTION(0);
50619   }
50620
50621   jresult = (void *)result;
50622   return jresult;
50623 }
50624
50625
50626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
50627   void * jresult ;
50628   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
50629   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
50630
50631   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
50632   if (!arg1) {
50633     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
50634     return 0;
50635   }
50636   {
50637     try {
50638       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
50639     } CALL_CATCH_EXCEPTION(0);
50640   }
50641
50642   jresult = (void *)result;
50643   return jresult;
50644 }
50645
50646
50647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
50648   void * jresult ;
50649   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
50650   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
50651   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
50652
50653   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
50654   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
50655   if (!arg2) {
50656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
50657     return 0;
50658   }
50659   {
50660     try {
50661       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
50662     } CALL_CATCH_EXCEPTION(0);
50663   }
50664
50665   jresult = (void *)result;
50666   return jresult;
50667 }
50668
50669
50670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
50671   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
50672
50673   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
50674   {
50675     try {
50676       delete arg1;
50677     } CALL_CATCH_EXCEPTION();
50678   }
50679
50680 }
50681
50682
50683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
50684   void * jresult ;
50685   Dali::Toolkit::PageFactory *arg1 = 0 ;
50686   Dali::Vector2 *arg2 = 0 ;
50687   Dali::Toolkit::PageTurnLandscapeView result;
50688
50689   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
50690   if (!arg1) {
50691     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
50692     return 0;
50693   }
50694   arg2 = (Dali::Vector2 *)jarg2;
50695   if (!arg2) {
50696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
50697     return 0;
50698   }
50699   {
50700     try {
50701       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
50702     } CALL_CATCH_EXCEPTION(0);
50703   }
50704
50705   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
50706   return jresult;
50707 }
50708
50709
50710 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
50711   void * jresult ;
50712   Dali::BaseHandle arg1 ;
50713   Dali::BaseHandle *argp1 ;
50714   Dali::Toolkit::PageTurnLandscapeView result;
50715
50716   argp1 = (Dali::BaseHandle *)jarg1;
50717   if (!argp1) {
50718     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
50719     return 0;
50720   }
50721   arg1 = *argp1;
50722   {
50723     try {
50724       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
50725     } CALL_CATCH_EXCEPTION(0);
50726   }
50727
50728   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
50729   return jresult;
50730 }
50731
50732
50733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
50734   void * jresult ;
50735   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
50736
50737   {
50738     try {
50739       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
50740     } CALL_CATCH_EXCEPTION(0);
50741   }
50742
50743   jresult = (void *)result;
50744   return jresult;
50745 }
50746
50747
50748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
50749   void * jresult ;
50750   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
50751   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
50752
50753   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
50754   if (!arg1) {
50755     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
50756     return 0;
50757   }
50758   {
50759     try {
50760       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
50761     } CALL_CATCH_EXCEPTION(0);
50762   }
50763
50764   jresult = (void *)result;
50765   return jresult;
50766 }
50767
50768
50769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
50770   void * jresult ;
50771   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
50772   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
50773   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
50774
50775   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
50776   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
50777   if (!arg2) {
50778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
50779     return 0;
50780   }
50781   {
50782     try {
50783       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
50784     } CALL_CATCH_EXCEPTION(0);
50785   }
50786
50787   jresult = (void *)result;
50788   return jresult;
50789 }
50790
50791
50792 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
50793   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
50794
50795   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
50796   {
50797     try {
50798       delete arg1;
50799     } CALL_CATCH_EXCEPTION();
50800   }
50801
50802 }
50803
50804
50805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
50806   void * jresult ;
50807   Dali::Toolkit::PageFactory *arg1 = 0 ;
50808   Dali::Vector2 *arg2 = 0 ;
50809   Dali::Toolkit::PageTurnPortraitView result;
50810
50811   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
50812   if (!arg1) {
50813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
50814     return 0;
50815   }
50816   arg2 = (Dali::Vector2 *)jarg2;
50817   if (!arg2) {
50818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
50819     return 0;
50820   }
50821   {
50822     try {
50823       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
50824     } CALL_CATCH_EXCEPTION(0);
50825   }
50826
50827   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
50828   return jresult;
50829 }
50830
50831
50832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
50833   void * jresult ;
50834   Dali::BaseHandle arg1 ;
50835   Dali::BaseHandle *argp1 ;
50836   Dali::Toolkit::PageTurnPortraitView result;
50837
50838   argp1 = (Dali::BaseHandle *)jarg1;
50839   if (!argp1) {
50840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
50841     return 0;
50842   }
50843   arg1 = *argp1;
50844   {
50845     try {
50846       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
50847     } CALL_CATCH_EXCEPTION(0);
50848   }
50849
50850   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
50851   return jresult;
50852 }
50853
50854
50855 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
50856   int jresult ;
50857   int result;
50858
50859   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
50860   jresult = (int)result;
50861   return jresult;
50862 }
50863
50864
50865 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
50866   int jresult ;
50867   int result;
50868
50869   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
50870   jresult = (int)result;
50871   return jresult;
50872 }
50873
50874
50875 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
50876   int jresult ;
50877   int result;
50878
50879   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
50880   jresult = (int)result;
50881   return jresult;
50882 }
50883
50884
50885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
50886   void * jresult ;
50887   Dali::Toolkit::ToggleButton::Property *result = 0 ;
50888
50889   {
50890     try {
50891       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
50892     } CALL_CATCH_EXCEPTION(0);
50893   }
50894
50895   jresult = (void *)result;
50896   return jresult;
50897 }
50898
50899
50900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
50901   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
50902
50903   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
50904   {
50905     try {
50906       delete arg1;
50907     } CALL_CATCH_EXCEPTION();
50908   }
50909
50910 }
50911
50912
50913 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
50914   void * jresult ;
50915   Dali::Toolkit::ToggleButton *result = 0 ;
50916
50917   {
50918     try {
50919       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
50920     } CALL_CATCH_EXCEPTION(0);
50921   }
50922
50923   jresult = (void *)result;
50924   return jresult;
50925 }
50926
50927
50928 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
50929   void * jresult ;
50930   Dali::Toolkit::ToggleButton *arg1 = 0 ;
50931   Dali::Toolkit::ToggleButton *result = 0 ;
50932
50933   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
50934   if (!arg1) {
50935     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
50936     return 0;
50937   }
50938   {
50939     try {
50940       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
50941     } CALL_CATCH_EXCEPTION(0);
50942   }
50943
50944   jresult = (void *)result;
50945   return jresult;
50946 }
50947
50948
50949 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
50950   void * jresult ;
50951   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
50952   Dali::Toolkit::ToggleButton *arg2 = 0 ;
50953   Dali::Toolkit::ToggleButton *result = 0 ;
50954
50955   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
50956   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
50957   if (!arg2) {
50958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
50959     return 0;
50960   }
50961   {
50962     try {
50963       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
50964     } CALL_CATCH_EXCEPTION(0);
50965   }
50966
50967   jresult = (void *)result;
50968   return jresult;
50969 }
50970
50971
50972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
50973   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
50974
50975   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
50976   {
50977     try {
50978       delete arg1;
50979     } CALL_CATCH_EXCEPTION();
50980   }
50981
50982 }
50983
50984
50985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
50986   void * jresult ;
50987   Dali::Toolkit::ToggleButton result;
50988
50989   {
50990     try {
50991       result = Dali::Toolkit::ToggleButton::New();
50992     } CALL_CATCH_EXCEPTION(0);
50993   }
50994
50995   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
50996   return jresult;
50997 }
50998
50999
51000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
51001   void * jresult ;
51002   Dali::BaseHandle arg1 ;
51003   Dali::BaseHandle *argp1 ;
51004   Dali::Toolkit::ToggleButton result;
51005
51006   argp1 = (Dali::BaseHandle *)jarg1;
51007   if (!argp1) {
51008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
51009     return 0;
51010   }
51011   arg1 = *argp1;
51012   {
51013     try {
51014       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
51015     } CALL_CATCH_EXCEPTION(0);
51016   }
51017
51018   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
51019   return jresult;
51020 }
51021
51022
51023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
51024   void * jresult ;
51025   Dali::Toolkit::Visual::Base *result = 0 ;
51026
51027   {
51028     try {
51029       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
51030     } CALL_CATCH_EXCEPTION(0);
51031   }
51032
51033   jresult = (void *)result;
51034   return jresult;
51035 }
51036
51037
51038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
51039   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
51040
51041   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
51042   {
51043     try {
51044       delete arg1;
51045     } CALL_CATCH_EXCEPTION();
51046   }
51047
51048 }
51049
51050
51051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
51052   void * jresult ;
51053   Dali::Toolkit::Visual::Base *arg1 = 0 ;
51054   Dali::Toolkit::Visual::Base *result = 0 ;
51055
51056   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
51057   if (!arg1) {
51058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
51059     return 0;
51060   }
51061   {
51062     try {
51063       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
51064     } CALL_CATCH_EXCEPTION(0);
51065   }
51066
51067   jresult = (void *)result;
51068   return jresult;
51069 }
51070
51071
51072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
51073   void * jresult ;
51074   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
51075   Dali::Toolkit::Visual::Base *arg2 = 0 ;
51076   Dali::Toolkit::Visual::Base *result = 0 ;
51077
51078   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
51079   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
51080   if (!arg2) {
51081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
51082     return 0;
51083   }
51084   {
51085     try {
51086       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
51087     } CALL_CATCH_EXCEPTION(0);
51088   }
51089
51090   jresult = (void *)result;
51091   return jresult;
51092 }
51093
51094
51095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
51096   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
51097   std::string *arg2 = 0 ;
51098
51099   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
51100   if (!jarg2) {
51101     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
51102     return ;
51103   }
51104   std::string arg2_str(jarg2);
51105   arg2 = &arg2_str;
51106   {
51107     try {
51108       (arg1)->SetName((std::string const &)*arg2);
51109     } CALL_CATCH_EXCEPTION();
51110   }
51111
51112
51113   //argout typemap for const std::string&
51114
51115 }
51116
51117
51118 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
51119   char * jresult ;
51120   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
51121   std::string *result = 0 ;
51122
51123   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
51124   {
51125     try {
51126       result = (std::string *) &(arg1)->GetName();
51127     } CALL_CATCH_EXCEPTION(0);
51128   }
51129
51130   jresult = SWIG_csharp_string_callback(result->c_str());
51131   return jresult;
51132 }
51133
51134
51135 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
51136   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
51137   Dali::Property::Map *arg2 = 0 ;
51138   Dali::Size arg3 ;
51139   Dali::Size *argp3 ;
51140
51141   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
51142   arg2 = (Dali::Property::Map *)jarg2;
51143   if (!arg2) {
51144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
51145     return ;
51146   }
51147   argp3 = (Dali::Size *)jarg3;
51148   if (!argp3) {
51149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
51150     return ;
51151   }
51152   arg3 = *argp3;
51153   {
51154     try {
51155       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
51156     } CALL_CATCH_EXCEPTION();
51157   }
51158
51159 }
51160
51161
51162 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
51163   float jresult ;
51164   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
51165   float arg2 ;
51166   float result;
51167
51168   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
51169   arg2 = (float)jarg2;
51170   {
51171     try {
51172       result = (float)(arg1)->GetHeightForWidth(arg2);
51173     } CALL_CATCH_EXCEPTION(0);
51174   }
51175
51176   jresult = result;
51177   return jresult;
51178 }
51179
51180
51181 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
51182   float jresult ;
51183   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
51184   float arg2 ;
51185   float result;
51186
51187   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
51188   arg2 = (float)jarg2;
51189   {
51190     try {
51191       result = (float)(arg1)->GetWidthForHeight(arg2);
51192     } CALL_CATCH_EXCEPTION(0);
51193   }
51194
51195   jresult = result;
51196   return jresult;
51197 }
51198
51199
51200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
51201   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
51202   Dali::Vector2 *arg2 = 0 ;
51203
51204   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
51205   arg2 = (Dali::Vector2 *)jarg2;
51206   if (!arg2) {
51207     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
51208     return ;
51209   }
51210   {
51211     try {
51212       (arg1)->GetNaturalSize(*arg2);
51213     } CALL_CATCH_EXCEPTION();
51214   }
51215
51216 }
51217
51218
51219 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, int jarg2) {
51220   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
51221   float arg2 ;
51222
51223   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
51224   arg2 = (int)jarg2;
51225   {
51226     try {
51227       (arg1)->SetDepthIndex(arg2);
51228     } CALL_CATCH_EXCEPTION();
51229   }
51230
51231 }
51232
51233
51234 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
51235   int jresult ;
51236   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
51237   int result;
51238
51239   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
51240   {
51241     try {
51242       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
51243     } CALL_CATCH_EXCEPTION(0);
51244   }
51245
51246   jresult = result;
51247   return jresult;
51248 }
51249
51250
51251 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
51252   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
51253   Dali::Property::Map *arg2 = 0 ;
51254
51255   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
51256   arg2 = (Dali::Property::Map *)jarg2;
51257   if (!arg2) {
51258     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
51259     return ;
51260   }
51261   {
51262     try {
51263       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
51264     } CALL_CATCH_EXCEPTION();
51265   }
51266
51267 }
51268
51269
51270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
51271   void * jresult ;
51272   Dali::Toolkit::VisualFactory result;
51273
51274   {
51275     try {
51276       result = Dali::Toolkit::VisualFactory::Get();
51277     } CALL_CATCH_EXCEPTION(0);
51278   }
51279
51280   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
51281   return jresult;
51282 }
51283
51284
51285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
51286   void * jresult ;
51287   Dali::Toolkit::VisualFactory *result = 0 ;
51288
51289   {
51290     try {
51291       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
51292     } CALL_CATCH_EXCEPTION(0);
51293   }
51294
51295   jresult = (void *)result;
51296   return jresult;
51297 }
51298
51299
51300 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
51301   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
51302
51303   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
51304   {
51305     try {
51306       delete arg1;
51307     } CALL_CATCH_EXCEPTION();
51308   }
51309
51310 }
51311
51312
51313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
51314   void * jresult ;
51315   Dali::Toolkit::VisualFactory *arg1 = 0 ;
51316   Dali::Toolkit::VisualFactory *result = 0 ;
51317
51318   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
51319   if (!arg1) {
51320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
51321     return 0;
51322   }
51323   {
51324     try {
51325       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
51326     } CALL_CATCH_EXCEPTION(0);
51327   }
51328
51329   jresult = (void *)result;
51330   return jresult;
51331 }
51332
51333
51334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
51335   void * jresult ;
51336   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
51337   Dali::Toolkit::VisualFactory *arg2 = 0 ;
51338   Dali::Toolkit::VisualFactory *result = 0 ;
51339
51340   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
51341   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
51342   if (!arg2) {
51343     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
51344     return 0;
51345   }
51346   {
51347     try {
51348       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
51349     } CALL_CATCH_EXCEPTION(0);
51350   }
51351
51352   jresult = (void *)result;
51353   return jresult;
51354 }
51355
51356
51357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
51358   void * jresult ;
51359   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
51360   Dali::Property::Map *arg2 = 0 ;
51361   Dali::Toolkit::Visual::Base result;
51362
51363   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
51364   arg2 = (Dali::Property::Map *)jarg2;
51365   if (!arg2) {
51366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
51367     return 0;
51368   }
51369   {
51370     try {
51371       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
51372     } CALL_CATCH_EXCEPTION(0);
51373   }
51374
51375   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
51376   return jresult;
51377 }
51378
51379
51380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
51381   void * jresult ;
51382   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
51383   std::string *arg2 = 0 ;
51384   Dali::ImageDimensions arg3 ;
51385   Dali::ImageDimensions *argp3 ;
51386   Dali::Toolkit::Visual::Base result;
51387
51388   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
51389   if (!jarg2) {
51390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
51391     return 0;
51392   }
51393   std::string arg2_str(jarg2);
51394   arg2 = &arg2_str;
51395   argp3 = (Dali::ImageDimensions *)jarg3;
51396   if (!argp3) {
51397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
51398     return 0;
51399   }
51400   arg3 = *argp3;
51401   {
51402     try {
51403       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
51404     } CALL_CATCH_EXCEPTION(0);
51405   }
51406
51407   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
51408
51409   //argout typemap for const std::string&
51410
51411   return jresult;
51412 }
51413
51414
51415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
51416   void * jresult ;
51417   Dali::Toolkit::AsyncImageLoader *result = 0 ;
51418
51419   {
51420     try {
51421       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
51422     } CALL_CATCH_EXCEPTION(0);
51423   }
51424
51425   jresult = (void *)result;
51426   return jresult;
51427 }
51428
51429
51430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
51431   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
51432
51433   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
51434   {
51435     try {
51436       delete arg1;
51437     } CALL_CATCH_EXCEPTION();
51438   }
51439
51440 }
51441
51442
51443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
51444   void * jresult ;
51445   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
51446   Dali::Toolkit::AsyncImageLoader *result = 0 ;
51447
51448   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
51449   if (!arg1) {
51450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
51451     return 0;
51452   }
51453   {
51454     try {
51455       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
51456     } CALL_CATCH_EXCEPTION(0);
51457   }
51458
51459   jresult = (void *)result;
51460   return jresult;
51461 }
51462
51463
51464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
51465   void * jresult ;
51466   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
51467   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
51468   Dali::Toolkit::AsyncImageLoader *result = 0 ;
51469
51470   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
51471   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
51472   if (!arg2) {
51473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
51474     return 0;
51475   }
51476   {
51477     try {
51478       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
51479     } CALL_CATCH_EXCEPTION(0);
51480   }
51481
51482   jresult = (void *)result;
51483   return jresult;
51484 }
51485
51486
51487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
51488   void * jresult ;
51489   Dali::Toolkit::AsyncImageLoader result;
51490
51491   {
51492     try {
51493       result = Dali::Toolkit::AsyncImageLoader::New();
51494     } CALL_CATCH_EXCEPTION(0);
51495   }
51496
51497   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
51498   return jresult;
51499 }
51500
51501
51502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
51503   void * jresult ;
51504   Dali::BaseHandle arg1 ;
51505   Dali::BaseHandle *argp1 ;
51506   Dali::Toolkit::AsyncImageLoader result;
51507
51508   argp1 = (Dali::BaseHandle *)jarg1;
51509   if (!argp1) {
51510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
51511     return 0;
51512   }
51513   arg1 = *argp1;
51514   {
51515     try {
51516       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
51517     } CALL_CATCH_EXCEPTION(0);
51518   }
51519
51520   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
51521   return jresult;
51522 }
51523
51524
51525 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
51526   unsigned int jresult ;
51527   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
51528   std::string *arg2 = 0 ;
51529   uint32_t result;
51530
51531   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
51532   if (!jarg2) {
51533     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
51534     return 0;
51535   }
51536   std::string arg2_str(jarg2);
51537   arg2 = &arg2_str;
51538   {
51539     try {
51540       result = (arg1)->Load((std::string const &)*arg2);
51541     } CALL_CATCH_EXCEPTION(0);
51542   }
51543
51544   jresult = result;
51545
51546   //argout typemap for const std::string&
51547
51548   return jresult;
51549 }
51550
51551
51552 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
51553   unsigned int jresult ;
51554   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
51555   std::string *arg2 = 0 ;
51556   Dali::ImageDimensions arg3 ;
51557   Dali::ImageDimensions *argp3 ;
51558   uint32_t result;
51559
51560   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
51561   if (!jarg2) {
51562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
51563     return 0;
51564   }
51565   std::string arg2_str(jarg2);
51566   arg2 = &arg2_str;
51567   argp3 = (Dali::ImageDimensions *)jarg3;
51568   if (!argp3) {
51569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
51570     return 0;
51571   }
51572   arg3 = *argp3;
51573   {
51574     try {
51575       result = (arg1)->Load((std::string const &)*arg2,arg3);
51576     } CALL_CATCH_EXCEPTION(0);
51577   }
51578
51579   jresult = result;
51580
51581   //argout typemap for const std::string&
51582
51583   return jresult;
51584 }
51585
51586
51587 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
51588   unsigned int jresult ;
51589   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
51590   std::string *arg2 = 0 ;
51591   Dali::ImageDimensions arg3 ;
51592   Dali::FittingMode::Type arg4 ;
51593   Dali::SamplingMode::Type arg5 ;
51594   bool arg6 ;
51595   Dali::ImageDimensions *argp3 ;
51596   uint32_t result;
51597
51598   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
51599   if (!jarg2) {
51600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
51601     return 0;
51602   }
51603   std::string arg2_str(jarg2);
51604   arg2 = &arg2_str;
51605   argp3 = (Dali::ImageDimensions *)jarg3;
51606   if (!argp3) {
51607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
51608     return 0;
51609   }
51610   arg3 = *argp3;
51611   arg4 = (Dali::FittingMode::Type)jarg4;
51612   arg5 = (Dali::SamplingMode::Type)jarg5;
51613   arg6 = jarg6 ? true : false;
51614   {
51615     try {
51616       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
51617     } CALL_CATCH_EXCEPTION(0);
51618   }
51619
51620   jresult = result;
51621
51622   //argout typemap for const std::string&
51623
51624   return jresult;
51625 }
51626
51627
51628 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
51629   unsigned int jresult ;
51630   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
51631   uint32_t arg2 ;
51632   bool result;
51633
51634   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
51635   arg2 = (uint32_t)jarg2;
51636   {
51637     try {
51638       result = (bool)(arg1)->Cancel(arg2);
51639     } CALL_CATCH_EXCEPTION(0);
51640   }
51641
51642   jresult = result;
51643   return jresult;
51644 }
51645
51646
51647 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
51648   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
51649
51650   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
51651   {
51652     try {
51653       (arg1)->CancelAll();
51654     } CALL_CATCH_EXCEPTION();
51655   }
51656
51657 }
51658
51659
51660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
51661   void * jresult ;
51662   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
51663   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
51664
51665   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
51666   {
51667     try {
51668       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
51669     } CALL_CATCH_EXCEPTION(0);
51670   }
51671
51672   jresult = (void *)result;
51673   return jresult;
51674 }
51675
51676
51677 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
51678   void * jresult ;
51679   std::string *arg1 = 0 ;
51680   Dali::PixelData result;
51681
51682   if (!jarg1) {
51683     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
51684     return 0;
51685   }
51686   std::string arg1_str(jarg1);
51687   arg1 = &arg1_str;
51688   {
51689     try {
51690       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
51691     } CALL_CATCH_EXCEPTION(0);
51692   }
51693
51694   jresult = new Dali::PixelData((const Dali::PixelData &)result);
51695
51696   //argout typemap for const std::string&
51697
51698   return jresult;
51699 }
51700
51701
51702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
51703   void * jresult ;
51704   std::string *arg1 = 0 ;
51705   Dali::ImageDimensions arg2 ;
51706   Dali::ImageDimensions *argp2 ;
51707   Dali::PixelData result;
51708
51709   if (!jarg1) {
51710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
51711     return 0;
51712   }
51713   std::string arg1_str(jarg1);
51714   arg1 = &arg1_str;
51715   argp2 = (Dali::ImageDimensions *)jarg2;
51716   if (!argp2) {
51717     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
51718     return 0;
51719   }
51720   arg2 = *argp2;
51721   {
51722     try {
51723       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
51724     } CALL_CATCH_EXCEPTION(0);
51725   }
51726
51727   jresult = new Dali::PixelData((const Dali::PixelData &)result);
51728
51729   //argout typemap for const std::string&
51730
51731   return jresult;
51732 }
51733
51734
51735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
51736   void * jresult ;
51737   std::string *arg1 = 0 ;
51738   Dali::ImageDimensions arg2 ;
51739   Dali::FittingMode::Type arg3 ;
51740   Dali::SamplingMode::Type arg4 ;
51741   bool arg5 ;
51742   Dali::ImageDimensions *argp2 ;
51743   Dali::PixelData result;
51744
51745   if (!jarg1) {
51746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
51747     return 0;
51748   }
51749   std::string arg1_str(jarg1);
51750   arg1 = &arg1_str;
51751   argp2 = (Dali::ImageDimensions *)jarg2;
51752   if (!argp2) {
51753     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
51754     return 0;
51755   }
51756   arg2 = *argp2;
51757   arg3 = (Dali::FittingMode::Type)jarg3;
51758   arg4 = (Dali::SamplingMode::Type)jarg4;
51759   arg5 = jarg5 ? true : false;
51760   {
51761     try {
51762       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
51763     } CALL_CATCH_EXCEPTION(0);
51764   }
51765
51766   jresult = new Dali::PixelData((const Dali::PixelData &)result);
51767
51768   //argout typemap for const std::string&
51769
51770   return jresult;
51771 }
51772
51773
51774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
51775   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
51776
51777   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
51778   {
51779     try {
51780       delete arg1;
51781     } CALL_CATCH_EXCEPTION();
51782   }
51783
51784 }
51785
51786
51787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
51788   void * jresult ;
51789   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
51790   Dali::Actor arg2 ;
51791   Dali::Actor arg3 ;
51792   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
51793   Dali::Actor *argp2 ;
51794   Dali::Actor *argp3 ;
51795   Dali::Actor result;
51796
51797   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
51798   argp2 = (Dali::Actor *)jarg2;
51799   if (!argp2) {
51800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51801     return 0;
51802   }
51803   arg2 = *argp2;
51804   argp3 = (Dali::Actor *)jarg3;
51805   if (!argp3) {
51806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51807     return 0;
51808   }
51809   arg3 = *argp3;
51810   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
51811   {
51812     try {
51813       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4);
51814     } CALL_CATCH_EXCEPTION(0);
51815   }
51816
51817   jresult = new Dali::Actor((const Dali::Actor &)result);
51818   return jresult;
51819 }
51820
51821
51822 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
51823   void * jresult ;
51824   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
51825
51826   {
51827     try {
51828       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
51829     } CALL_CATCH_EXCEPTION(0);
51830   }
51831
51832   jresult = (void *)result;
51833   return jresult;
51834 }
51835
51836
51837 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_director_connect(void *objarg, SwigDirector_FrameCallbackInterface::SWIG_Callback0_t callback0) {
51838   Dali::FrameCallbackInterface *obj = (Dali::FrameCallbackInterface *)objarg;
51839   SwigDirector_FrameCallbackInterface *director = dynamic_cast<SwigDirector_FrameCallbackInterface *>(obj);
51840   if (director) {
51841     director->swig_connect_director(callback0);
51842   }
51843 }
51844
51845
51846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameCallbackInterface() {
51847   void * jresult ;
51848   Dali::FrameCallbackInterface *result = 0 ;
51849
51850   {
51851     try {
51852       result =(Dali::FrameCallbackInterface *) new SwigDirector_FrameCallbackInterface();
51853     } CALL_CATCH_EXCEPTION(0);
51854   }
51855
51856   jresult = (void *)result;
51857   return jresult;
51858 }
51859
51860 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetPosition(void * updateProxy, unsigned int id,  void* position) {
51861   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
51862   Dali::Vector3* vector3 = (Dali::Vector3 *)position;
51863   return proxy->GetPosition(id, *vector3);
51864 }
51865
51866 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetPosition(void * updateProxy, unsigned int id, void* position) {
51867   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
51868   Dali::Vector3* vector3 = (Dali::Vector3 *)position;
51869   return proxy->SetPosition(id, *vector3);
51870 }
51871
51872 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakePosition(void * updateProxy, unsigned int id, void* position) {
51873   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
51874   Dali::Vector3* vector3 = (Dali::Vector3 *)position;
51875   return proxy->BakePosition(id, *vector3);
51876 }
51877
51878 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetSize(void * updateProxy, unsigned int id, void* size) {
51879   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
51880   Dali::Vector3* vector3 = (Dali::Vector3 *)size;
51881   return proxy->GetSize(id, *vector3);
51882 }
51883
51884 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetSize(void * updateProxy, unsigned int id, void* size) {
51885   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
51886   Dali::Vector3* vector3 = (Dali::Vector3 *)size;
51887   return proxy->SetSize(id, *vector3);
51888 }
51889 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakeSize(void * updateProxy, unsigned int id, void* size) {
51890   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
51891   Dali::Vector3* vector3 = (Dali::Vector3 *)size;
51892   return proxy->BakeSize(id, *vector3);
51893 }
51894
51895 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetPositionAndSize(void * updateProxy, unsigned int id, void* position, void* size) {
51896   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
51897   Dali::Vector3* vector3_pos = (Dali::Vector3 *)position;
51898   Dali::Vector3* vector3_size = (Dali::Vector3 *)size;
51899   return proxy->GetPositionAndSize(id, *vector3_pos, *vector3_size);
51900 }
51901
51902 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetScale(void * updateProxy, unsigned int id, void* scale) {
51903   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
51904   Dali::Vector3* vector3 = (Dali::Vector3 *)scale;
51905   return proxy->GetScale(id,* vector3);
51906 }
51907
51908 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetScale(void * updateProxy, unsigned int id, void* scale) {
51909   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
51910   Dali::Vector3* vector3 = (Dali::Vector3 *)scale;
51911   return proxy->SetScale(id, *vector3);
51912 }
51913
51914 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakeScale(void * updateProxy, unsigned int id, void* scale) {
51915   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
51916   Dali::Vector3* vector3 = (Dali::Vector3 *)scale;
51917   return proxy->BakeScale(id, *vector3);
51918 }
51919
51920 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetColor(void * updateProxy, unsigned int id, void* color) {
51921   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
51922   Dali::Vector4* vector4 = (Dali::Vector4 *)color;
51923   return proxy->GetColor(id, *vector4);
51924 }
51925
51926 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetColor(void * updateProxy, unsigned int id, void* color) {
51927   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
51928   Dali::Vector4* vector4 = (Dali::Vector4 *)color;
51929   return proxy->SetColor(id, *vector4);
51930 }
51931
51932 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakeColor(void * updateProxy, unsigned int id, void* color) {
51933   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
51934   Dali::Vector4* vector4 = (Dali::Vector4 *)color;
51935   return proxy->BakeColor(id, *vector4);
51936 }
51937
51938 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_AddFrameCallback(void * jarg1, void* jarg2, void* jarg3) {
51939   Dali::FrameCallbackInterface *obj = (Dali::FrameCallbackInterface *)jarg2;
51940   SwigDirector_FrameCallbackInterface *arg2 = dynamic_cast<SwigDirector_FrameCallbackInterface *>(obj);
51941
51942   Dali::Stage *arg1 = (Dali::Stage *) 0;
51943   Dali::Actor *arg3 = 0;
51944
51945   arg1 = (Dali::Stage *)jarg1;
51946   arg3 = (Dali::Actor *)jarg3;
51947
51948   DevelStage::AddFrameCallback( *arg1, *arg2, *arg3 );
51949   return;
51950 }
51951
51952 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_RemoveFrameCallback(void * jarg1, void* jarg2) {
51953
51954   Dali::FrameCallbackInterface *obj = (Dali::FrameCallbackInterface *)jarg2;
51955   SwigDirector_FrameCallbackInterface *arg2 = dynamic_cast<SwigDirector_FrameCallbackInterface *>(obj);
51956
51957   Dali::Stage *arg1 = (Dali::Stage *) 0;
51958
51959   arg1 = (Dali::Stage *)jarg1;
51960
51961   DevelStage::RemoveFrameCallback( *arg1, *arg2 );
51962   return;
51963 }
51964
51965 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
51966   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
51967   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
51968   if (director) {
51969     director->swig_connect_director(callback0);
51970   }
51971 }
51972
51973 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
51974   KeyboardFocusManager arg1 ;
51975   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
51976   KeyboardFocusManager *argp1 ;
51977
51978   argp1 = (KeyboardFocusManager *)jarg1;
51979   if (!argp1) {
51980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
51981     return ;
51982   }
51983   arg1 = *argp1;
51984   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
51985   //Null checking of arg2 is removed. arg2's null set means resetting so it can be a null value.
51986   {
51987     try {
51988       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
51989     } CALL_CATCH_EXCEPTION();
51990   }
51991
51992 }
51993
51994
51995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
51996   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
51997
51998   arg1 = (std::vector< unsigned int > *)jarg1;
51999   {
52000     try {
52001       (arg1)->clear();
52002     } CALL_CATCH_EXCEPTION();
52003   }
52004
52005 }
52006
52007
52008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
52009   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52010   unsigned int *arg2 = 0 ;
52011   unsigned int temp2 ;
52012
52013   arg1 = (std::vector< unsigned int > *)jarg1;
52014   temp2 = (unsigned int)jarg2;
52015   arg2 = &temp2;
52016   {
52017     try {
52018       (arg1)->push_back((unsigned int const &)*arg2);
52019     } CALL_CATCH_EXCEPTION();
52020   }
52021
52022 }
52023
52024
52025 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
52026   unsigned long jresult ;
52027   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52028   std::vector< unsigned int >::size_type result;
52029
52030   arg1 = (std::vector< unsigned int > *)jarg1;
52031   {
52032     try {
52033       result = ((std::vector< unsigned int > const *)arg1)->size();
52034     } CALL_CATCH_EXCEPTION(0);
52035   }
52036
52037   jresult = (unsigned long)result;
52038   return jresult;
52039 }
52040
52041
52042 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
52043   unsigned long jresult ;
52044   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52045   std::vector< unsigned int >::size_type result;
52046
52047   arg1 = (std::vector< unsigned int > *)jarg1;
52048   {
52049     try {
52050       result = ((std::vector< unsigned int > const *)arg1)->capacity();
52051     } CALL_CATCH_EXCEPTION(0);
52052   }
52053
52054   jresult = (unsigned long)result;
52055   return jresult;
52056 }
52057
52058
52059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
52060   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52061   std::vector< unsigned int >::size_type arg2 ;
52062
52063   arg1 = (std::vector< unsigned int > *)jarg1;
52064   arg2 = (std::vector< unsigned int >::size_type)jarg2;
52065   {
52066     try {
52067       (arg1)->reserve(arg2);
52068     } CALL_CATCH_EXCEPTION();
52069   }
52070
52071 }
52072
52073
52074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
52075   void * jresult ;
52076   std::vector< unsigned int > *result = 0 ;
52077
52078   {
52079     try {
52080       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
52081     } CALL_CATCH_EXCEPTION(0);
52082   }
52083
52084   jresult = (void *)result;
52085   return jresult;
52086 }
52087
52088
52089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
52090   void * jresult ;
52091   std::vector< unsigned int > *arg1 = 0 ;
52092   std::vector< unsigned int > *result = 0 ;
52093
52094   arg1 = (std::vector< unsigned int > *)jarg1;
52095   if (!arg1) {
52096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
52097     return 0;
52098   }
52099   {
52100     try {
52101       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
52102     } CALL_CATCH_EXCEPTION(0);
52103   }
52104
52105   jresult = (void *)result;
52106   return jresult;
52107 }
52108
52109
52110 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
52111   void * jresult ;
52112   int arg1 ;
52113   std::vector< unsigned int > *result = 0 ;
52114
52115   arg1 = (int)jarg1;
52116   {
52117     try {
52118       try {
52119         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
52120       }
52121       catch(std::out_of_range &_e) {
52122         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52123         return 0;
52124       }
52125
52126     } CALL_CATCH_EXCEPTION(0);
52127   }
52128
52129   jresult = (void *)result;
52130   return jresult;
52131 }
52132
52133
52134 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
52135   unsigned int jresult ;
52136   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52137   int arg2 ;
52138   unsigned int result;
52139
52140   arg1 = (std::vector< unsigned int > *)jarg1;
52141   arg2 = (int)jarg2;
52142   {
52143     try {
52144       try {
52145         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
52146       }
52147       catch(std::out_of_range &_e) {
52148         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52149         return 0;
52150       }
52151
52152     } CALL_CATCH_EXCEPTION(0);
52153   }
52154
52155   jresult = result;
52156   return jresult;
52157 }
52158
52159
52160 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
52161   unsigned int jresult ;
52162   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52163   int arg2 ;
52164   unsigned int *result = 0 ;
52165
52166   arg1 = (std::vector< unsigned int > *)jarg1;
52167   arg2 = (int)jarg2;
52168   {
52169     try {
52170       try {
52171         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
52172       }
52173       catch(std::out_of_range &_e) {
52174         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52175         return 0;
52176       }
52177
52178     } CALL_CATCH_EXCEPTION(0);
52179   }
52180
52181   jresult = *result;
52182   return jresult;
52183 }
52184
52185
52186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
52187   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52188   int arg2 ;
52189   unsigned int *arg3 = 0 ;
52190   unsigned int temp3 ;
52191
52192   arg1 = (std::vector< unsigned int > *)jarg1;
52193   arg2 = (int)jarg2;
52194   temp3 = (unsigned int)jarg3;
52195   arg3 = &temp3;
52196   {
52197     try {
52198       try {
52199         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
52200       }
52201       catch(std::out_of_range &_e) {
52202         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52203         return ;
52204       }
52205
52206     } CALL_CATCH_EXCEPTION();
52207   }
52208
52209 }
52210
52211
52212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
52213   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52214   std::vector< unsigned int > *arg2 = 0 ;
52215
52216   arg1 = (std::vector< unsigned int > *)jarg1;
52217   arg2 = (std::vector< unsigned int > *)jarg2;
52218   if (!arg2) {
52219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
52220     return ;
52221   }
52222   {
52223     try {
52224       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
52225     } CALL_CATCH_EXCEPTION();
52226   }
52227
52228 }
52229
52230
52231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
52232   void * jresult ;
52233   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52234   int arg2 ;
52235   int arg3 ;
52236   std::vector< unsigned int > *result = 0 ;
52237
52238   arg1 = (std::vector< unsigned int > *)jarg1;
52239   arg2 = (int)jarg2;
52240   arg3 = (int)jarg3;
52241   {
52242     try {
52243       try {
52244         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
52245       }
52246       catch(std::out_of_range &_e) {
52247         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52248         return 0;
52249       }
52250       catch(std::invalid_argument &_e) {
52251         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
52252         return 0;
52253       }
52254
52255     } CALL_CATCH_EXCEPTION(0);
52256   }
52257
52258   jresult = (void *)result;
52259   return jresult;
52260 }
52261
52262
52263 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
52264   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52265   int arg2 ;
52266   unsigned int *arg3 = 0 ;
52267   unsigned int temp3 ;
52268
52269   arg1 = (std::vector< unsigned int > *)jarg1;
52270   arg2 = (int)jarg2;
52271   temp3 = (unsigned int)jarg3;
52272   arg3 = &temp3;
52273   {
52274     try {
52275       try {
52276         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
52277       }
52278       catch(std::out_of_range &_e) {
52279         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52280         return ;
52281       }
52282
52283     } CALL_CATCH_EXCEPTION();
52284   }
52285
52286 }
52287
52288
52289 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
52290   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52291   int arg2 ;
52292   std::vector< unsigned int > *arg3 = 0 ;
52293
52294   arg1 = (std::vector< unsigned int > *)jarg1;
52295   arg2 = (int)jarg2;
52296   arg3 = (std::vector< unsigned int > *)jarg3;
52297   if (!arg3) {
52298     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
52299     return ;
52300   }
52301   {
52302     try {
52303       try {
52304         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
52305       }
52306       catch(std::out_of_range &_e) {
52307         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52308         return ;
52309       }
52310
52311     } CALL_CATCH_EXCEPTION();
52312   }
52313
52314 }
52315
52316
52317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
52318   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52319   int arg2 ;
52320
52321   arg1 = (std::vector< unsigned int > *)jarg1;
52322   arg2 = (int)jarg2;
52323   {
52324     try {
52325       try {
52326         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
52327       }
52328       catch(std::out_of_range &_e) {
52329         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52330         return ;
52331       }
52332
52333     } CALL_CATCH_EXCEPTION();
52334   }
52335
52336 }
52337
52338
52339 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
52340   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52341   int arg2 ;
52342   int arg3 ;
52343
52344   arg1 = (std::vector< unsigned int > *)jarg1;
52345   arg2 = (int)jarg2;
52346   arg3 = (int)jarg3;
52347   {
52348     try {
52349       try {
52350         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
52351       }
52352       catch(std::out_of_range &_e) {
52353         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52354         return ;
52355       }
52356       catch(std::invalid_argument &_e) {
52357         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
52358         return ;
52359       }
52360
52361     } CALL_CATCH_EXCEPTION();
52362   }
52363
52364 }
52365
52366
52367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
52368   void * jresult ;
52369   unsigned int *arg1 = 0 ;
52370   int arg2 ;
52371   unsigned int temp1 ;
52372   std::vector< unsigned int > *result = 0 ;
52373
52374   temp1 = (unsigned int)jarg1;
52375   arg1 = &temp1;
52376   arg2 = (int)jarg2;
52377   {
52378     try {
52379       try {
52380         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
52381       }
52382       catch(std::out_of_range &_e) {
52383         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52384         return 0;
52385       }
52386
52387     } CALL_CATCH_EXCEPTION(0);
52388   }
52389
52390   jresult = (void *)result;
52391   return jresult;
52392 }
52393
52394
52395 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
52396   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52397
52398   arg1 = (std::vector< unsigned int > *)jarg1;
52399   {
52400     try {
52401       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
52402     } CALL_CATCH_EXCEPTION();
52403   }
52404
52405 }
52406
52407
52408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
52409   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52410   int arg2 ;
52411   int arg3 ;
52412
52413   arg1 = (std::vector< unsigned int > *)jarg1;
52414   arg2 = (int)jarg2;
52415   arg3 = (int)jarg3;
52416   {
52417     try {
52418       try {
52419         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
52420       }
52421       catch(std::out_of_range &_e) {
52422         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52423         return ;
52424       }
52425       catch(std::invalid_argument &_e) {
52426         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
52427         return ;
52428       }
52429
52430     } CALL_CATCH_EXCEPTION();
52431   }
52432
52433 }
52434
52435
52436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
52437   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52438   int arg2 ;
52439   std::vector< unsigned int > *arg3 = 0 ;
52440
52441   arg1 = (std::vector< unsigned int > *)jarg1;
52442   arg2 = (int)jarg2;
52443   arg3 = (std::vector< unsigned int > *)jarg3;
52444   if (!arg3) {
52445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
52446     return ;
52447   }
52448   {
52449     try {
52450       try {
52451         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
52452       }
52453       catch(std::out_of_range &_e) {
52454         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52455         return ;
52456       }
52457
52458     } CALL_CATCH_EXCEPTION();
52459   }
52460
52461 }
52462
52463
52464 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
52465   unsigned int jresult ;
52466   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52467   unsigned int *arg2 = 0 ;
52468   unsigned int temp2 ;
52469   bool result;
52470
52471   arg1 = (std::vector< unsigned int > *)jarg1;
52472   temp2 = (unsigned int)jarg2;
52473   arg2 = &temp2;
52474   {
52475     try {
52476       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
52477     } CALL_CATCH_EXCEPTION(0);
52478   }
52479
52480   jresult = result;
52481   return jresult;
52482 }
52483
52484
52485 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
52486   int jresult ;
52487   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52488   unsigned int *arg2 = 0 ;
52489   unsigned int temp2 ;
52490   int result;
52491
52492   arg1 = (std::vector< unsigned int > *)jarg1;
52493   temp2 = (unsigned int)jarg2;
52494   arg2 = &temp2;
52495   {
52496     try {
52497       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
52498     } CALL_CATCH_EXCEPTION(0);
52499   }
52500
52501   jresult = result;
52502   return jresult;
52503 }
52504
52505
52506 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
52507   int jresult ;
52508   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52509   unsigned int *arg2 = 0 ;
52510   unsigned int temp2 ;
52511   int result;
52512
52513   arg1 = (std::vector< unsigned int > *)jarg1;
52514   temp2 = (unsigned int)jarg2;
52515   arg2 = &temp2;
52516   {
52517     try {
52518       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
52519     } CALL_CATCH_EXCEPTION(0);
52520   }
52521
52522   jresult = result;
52523   return jresult;
52524 }
52525
52526
52527 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
52528   unsigned int jresult ;
52529   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52530   unsigned int *arg2 = 0 ;
52531   unsigned int temp2 ;
52532   bool result;
52533
52534   arg1 = (std::vector< unsigned int > *)jarg1;
52535   temp2 = (unsigned int)jarg2;
52536   arg2 = &temp2;
52537   {
52538     try {
52539       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
52540     } CALL_CATCH_EXCEPTION(0);
52541   }
52542
52543   jresult = result;
52544   return jresult;
52545 }
52546
52547
52548 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
52549   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52550
52551   arg1 = (std::vector< unsigned int > *)jarg1;
52552   {
52553     try {
52554       delete arg1;
52555     } CALL_CATCH_EXCEPTION();
52556   }
52557
52558 }
52559
52560
52561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
52562   void * jresult ;
52563   std::pair< unsigned int,Dali::Actor > *result = 0 ;
52564
52565   {
52566     try {
52567       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
52568     } CALL_CATCH_EXCEPTION(0);
52569   }
52570
52571   jresult = (void *)result;
52572   return jresult;
52573 }
52574
52575
52576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
52577   void * jresult ;
52578   unsigned int arg1 ;
52579   Dali::Actor arg2 ;
52580   Dali::Actor *argp2 ;
52581   std::pair< unsigned int,Dali::Actor > *result = 0 ;
52582
52583   arg1 = (unsigned int)jarg1;
52584   argp2 = (Dali::Actor *)jarg2;
52585   if (!argp2) {
52586     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
52587     return 0;
52588   }
52589   arg2 = *argp2;
52590   {
52591     try {
52592       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
52593     } CALL_CATCH_EXCEPTION(0);
52594   }
52595
52596   jresult = (void *)result;
52597   return jresult;
52598 }
52599
52600
52601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
52602   void * jresult ;
52603   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
52604   std::pair< unsigned int,Dali::Actor > *result = 0 ;
52605
52606   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
52607   if (!arg1) {
52608     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
52609     return 0;
52610   }
52611   {
52612     try {
52613       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
52614     } CALL_CATCH_EXCEPTION(0);
52615   }
52616
52617   jresult = (void *)result;
52618   return jresult;
52619 }
52620
52621
52622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
52623   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
52624   unsigned int arg2 ;
52625
52626   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
52627   arg2 = (unsigned int)jarg2;
52628   if (arg1) (arg1)->first = arg2;
52629 }
52630
52631
52632 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
52633   unsigned int jresult ;
52634   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
52635   unsigned int result;
52636
52637   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
52638   result = (unsigned int) ((arg1)->first);
52639   jresult = result;
52640   return jresult;
52641 }
52642
52643
52644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
52645   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
52646   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
52647
52648   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
52649   arg2 = (Dali::Actor *)jarg2;
52650   if (arg1) (arg1)->second = *arg2;
52651 }
52652
52653
52654 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
52655   void * jresult ;
52656   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
52657   Dali::Actor *result = 0 ;
52658
52659   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
52660   result = (Dali::Actor *)& ((arg1)->second);
52661   jresult = (void *)result;
52662   return jresult;
52663 }
52664
52665
52666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
52667   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
52668
52669   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
52670   {
52671     try {
52672       delete arg1;
52673     } CALL_CATCH_EXCEPTION();
52674   }
52675
52676 }
52677
52678
52679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
52680   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
52681
52682   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52683   {
52684     try {
52685       (arg1)->clear();
52686     } CALL_CATCH_EXCEPTION();
52687   }
52688
52689 }
52690
52691
52692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
52693   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
52694   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
52695
52696   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52697   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
52698   if (!arg2) {
52699     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
52700     return ;
52701   }
52702   {
52703     try {
52704       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
52705     } CALL_CATCH_EXCEPTION();
52706   }
52707
52708 }
52709
52710
52711 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
52712   unsigned long jresult ;
52713   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
52714   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
52715
52716   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52717   {
52718     try {
52719       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
52720     } CALL_CATCH_EXCEPTION(0);
52721   }
52722
52723   jresult = (unsigned long)result;
52724   return jresult;
52725 }
52726
52727
52728 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
52729   unsigned long jresult ;
52730   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
52731   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
52732
52733   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52734   {
52735     try {
52736       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
52737     } CALL_CATCH_EXCEPTION(0);
52738   }
52739
52740   jresult = (unsigned long)result;
52741   return jresult;
52742 }
52743
52744
52745 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
52746   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
52747   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
52748
52749   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52750   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
52751   {
52752     try {
52753       (arg1)->reserve(arg2);
52754     } CALL_CATCH_EXCEPTION();
52755   }
52756
52757 }
52758
52759
52760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
52761   void * jresult ;
52762   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
52763
52764   {
52765     try {
52766       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
52767     } CALL_CATCH_EXCEPTION(0);
52768   }
52769
52770   jresult = (void *)result;
52771   return jresult;
52772 }
52773
52774
52775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
52776   void * jresult ;
52777   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
52778   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
52779
52780   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52781   if (!arg1) {
52782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
52783     return 0;
52784   }
52785   {
52786     try {
52787       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);
52788     } CALL_CATCH_EXCEPTION(0);
52789   }
52790
52791   jresult = (void *)result;
52792   return jresult;
52793 }
52794
52795
52796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
52797   void * jresult ;
52798   int arg1 ;
52799   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
52800
52801   arg1 = (int)jarg1;
52802   {
52803     try {
52804       try {
52805         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);
52806       }
52807       catch(std::out_of_range &_e) {
52808         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52809         return 0;
52810       }
52811
52812     } CALL_CATCH_EXCEPTION(0);
52813   }
52814
52815   jresult = (void *)result;
52816   return jresult;
52817 }
52818
52819
52820 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
52821   void * jresult ;
52822   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
52823   int arg2 ;
52824   std::pair< unsigned int,Dali::Actor > result;
52825
52826   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52827   arg2 = (int)jarg2;
52828   {
52829     try {
52830       try {
52831         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
52832       }
52833       catch(std::out_of_range &_e) {
52834         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52835         return 0;
52836       }
52837
52838     } CALL_CATCH_EXCEPTION(0);
52839   }
52840
52841   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
52842   return jresult;
52843 }
52844
52845
52846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
52847   void * jresult ;
52848   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
52849   int arg2 ;
52850   std::pair< unsigned int,Dali::Actor > *result = 0 ;
52851
52852   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52853   arg2 = (int)jarg2;
52854   {
52855     try {
52856       try {
52857         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
52858       }
52859       catch(std::out_of_range &_e) {
52860         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52861         return 0;
52862       }
52863
52864     } CALL_CATCH_EXCEPTION(0);
52865   }
52866
52867   jresult = (void *)result;
52868   return jresult;
52869 }
52870
52871
52872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
52873   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
52874   int arg2 ;
52875   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
52876
52877   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52878   arg2 = (int)jarg2;
52879   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
52880   if (!arg3) {
52881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
52882     return ;
52883   }
52884   {
52885     try {
52886       try {
52887         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);
52888       }
52889       catch(std::out_of_range &_e) {
52890         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52891         return ;
52892       }
52893
52894     } CALL_CATCH_EXCEPTION();
52895   }
52896
52897 }
52898
52899
52900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
52901   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
52902   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
52903
52904   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52905   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
52906   if (!arg2) {
52907     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
52908     return ;
52909   }
52910   {
52911     try {
52912       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);
52913     } CALL_CATCH_EXCEPTION();
52914   }
52915
52916 }
52917
52918
52919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
52920   void * jresult ;
52921   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
52922   int arg2 ;
52923   int arg3 ;
52924   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
52925
52926   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52927   arg2 = (int)jarg2;
52928   arg3 = (int)jarg3;
52929   {
52930     try {
52931       try {
52932         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);
52933       }
52934       catch(std::out_of_range &_e) {
52935         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52936         return 0;
52937       }
52938       catch(std::invalid_argument &_e) {
52939         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
52940         return 0;
52941       }
52942
52943     } CALL_CATCH_EXCEPTION(0);
52944   }
52945
52946   jresult = (void *)result;
52947   return jresult;
52948 }
52949
52950
52951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
52952   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
52953   int arg2 ;
52954   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
52955
52956   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52957   arg2 = (int)jarg2;
52958   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
52959   if (!arg3) {
52960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
52961     return ;
52962   }
52963   {
52964     try {
52965       try {
52966         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);
52967       }
52968       catch(std::out_of_range &_e) {
52969         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52970         return ;
52971       }
52972
52973     } CALL_CATCH_EXCEPTION();
52974   }
52975
52976 }
52977
52978
52979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
52980   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
52981   int arg2 ;
52982   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
52983
52984   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52985   arg2 = (int)jarg2;
52986   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
52987   if (!arg3) {
52988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
52989     return ;
52990   }
52991   {
52992     try {
52993       try {
52994         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);
52995       }
52996       catch(std::out_of_range &_e) {
52997         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52998         return ;
52999       }
53000
53001     } CALL_CATCH_EXCEPTION();
53002   }
53003
53004 }
53005
53006
53007 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
53008   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
53009   int arg2 ;
53010
53011   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
53012   arg2 = (int)jarg2;
53013   {
53014     try {
53015       try {
53016         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
53017       }
53018       catch(std::out_of_range &_e) {
53019         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53020         return ;
53021       }
53022
53023     } CALL_CATCH_EXCEPTION();
53024   }
53025
53026 }
53027
53028
53029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
53030   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
53031   int arg2 ;
53032   int arg3 ;
53033
53034   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
53035   arg2 = (int)jarg2;
53036   arg3 = (int)jarg3;
53037   {
53038     try {
53039       try {
53040         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
53041       }
53042       catch(std::out_of_range &_e) {
53043         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53044         return ;
53045       }
53046       catch(std::invalid_argument &_e) {
53047         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
53048         return ;
53049       }
53050
53051     } CALL_CATCH_EXCEPTION();
53052   }
53053
53054 }
53055
53056
53057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
53058   void * jresult ;
53059   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
53060   int arg2 ;
53061   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
53062
53063   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
53064   if (!arg1) {
53065     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
53066     return 0;
53067   }
53068   arg2 = (int)jarg2;
53069   {
53070     try {
53071       try {
53072         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);
53073       }
53074       catch(std::out_of_range &_e) {
53075         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53076         return 0;
53077       }
53078
53079     } CALL_CATCH_EXCEPTION(0);
53080   }
53081
53082   jresult = (void *)result;
53083   return jresult;
53084 }
53085
53086
53087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
53088   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
53089
53090   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
53091   {
53092     try {
53093       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
53094     } CALL_CATCH_EXCEPTION();
53095   }
53096
53097 }
53098
53099
53100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
53101   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
53102   int arg2 ;
53103   int arg3 ;
53104
53105   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
53106   arg2 = (int)jarg2;
53107   arg3 = (int)jarg3;
53108   {
53109     try {
53110       try {
53111         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
53112       }
53113       catch(std::out_of_range &_e) {
53114         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53115         return ;
53116       }
53117       catch(std::invalid_argument &_e) {
53118         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
53119         return ;
53120       }
53121
53122     } CALL_CATCH_EXCEPTION();
53123   }
53124
53125 }
53126
53127
53128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
53129   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
53130   int arg2 ;
53131   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
53132
53133   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
53134   arg2 = (int)jarg2;
53135   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
53136   if (!arg3) {
53137     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
53138     return ;
53139   }
53140   {
53141     try {
53142       try {
53143         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);
53144       }
53145       catch(std::out_of_range &_e) {
53146         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53147         return ;
53148       }
53149
53150     } CALL_CATCH_EXCEPTION();
53151   }
53152
53153 }
53154
53155
53156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
53157   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
53158
53159   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
53160   {
53161     try {
53162       delete arg1;
53163     } CALL_CATCH_EXCEPTION();
53164   }
53165
53166 }
53167
53168
53169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
53170   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53171
53172   arg1 = (std::vector< Dali::Actor > *)jarg1;
53173   {
53174     try {
53175       (arg1)->clear();
53176     } CALL_CATCH_EXCEPTION();
53177   }
53178
53179 }
53180
53181
53182 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
53183   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53184   Dali::Actor *arg2 = 0 ;
53185
53186   arg1 = (std::vector< Dali::Actor > *)jarg1;
53187   arg2 = (Dali::Actor *)jarg2;
53188   if (!arg2) {
53189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
53190     return ;
53191   }
53192   {
53193     try {
53194       (arg1)->push_back((Dali::Actor const &)*arg2);
53195     } CALL_CATCH_EXCEPTION();
53196   }
53197
53198 }
53199
53200
53201 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
53202   unsigned long jresult ;
53203   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53204   std::vector< Dali::Actor >::size_type result;
53205
53206   arg1 = (std::vector< Dali::Actor > *)jarg1;
53207   {
53208     try {
53209       result = ((std::vector< Dali::Actor > const *)arg1)->size();
53210     } CALL_CATCH_EXCEPTION(0);
53211   }
53212
53213   jresult = (unsigned long)result;
53214   return jresult;
53215 }
53216
53217
53218 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
53219   unsigned long jresult ;
53220   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53221   std::vector< Dali::Actor >::size_type result;
53222
53223   arg1 = (std::vector< Dali::Actor > *)jarg1;
53224   {
53225     try {
53226       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
53227     } CALL_CATCH_EXCEPTION(0);
53228   }
53229
53230   jresult = (unsigned long)result;
53231   return jresult;
53232 }
53233
53234
53235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
53236   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53237   std::vector< Dali::Actor >::size_type arg2 ;
53238
53239   arg1 = (std::vector< Dali::Actor > *)jarg1;
53240   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
53241   {
53242     try {
53243       (arg1)->reserve(arg2);
53244     } CALL_CATCH_EXCEPTION();
53245   }
53246
53247 }
53248
53249
53250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
53251   void * jresult ;
53252   std::vector< Dali::Actor > *result = 0 ;
53253
53254   {
53255     try {
53256       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
53257     } CALL_CATCH_EXCEPTION(0);
53258   }
53259
53260   jresult = (void *)result;
53261   return jresult;
53262 }
53263
53264
53265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
53266   void * jresult ;
53267   std::vector< Dali::Actor > *arg1 = 0 ;
53268   std::vector< Dali::Actor > *result = 0 ;
53269
53270   arg1 = (std::vector< Dali::Actor > *)jarg1;
53271   if (!arg1) {
53272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
53273     return 0;
53274   }
53275   {
53276     try {
53277       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
53278     } CALL_CATCH_EXCEPTION(0);
53279   }
53280
53281   jresult = (void *)result;
53282   return jresult;
53283 }
53284
53285
53286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
53287   void * jresult ;
53288   int arg1 ;
53289   std::vector< Dali::Actor > *result = 0 ;
53290
53291   arg1 = (int)jarg1;
53292   {
53293     try {
53294       try {
53295         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
53296       }
53297       catch(std::out_of_range &_e) {
53298         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53299         return 0;
53300       }
53301
53302     } CALL_CATCH_EXCEPTION(0);
53303   }
53304
53305   jresult = (void *)result;
53306   return jresult;
53307 }
53308
53309
53310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
53311   void * jresult ;
53312   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53313   int arg2 ;
53314   Dali::Actor result;
53315
53316   arg1 = (std::vector< Dali::Actor > *)jarg1;
53317   arg2 = (int)jarg2;
53318   {
53319     try {
53320       try {
53321         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
53322       }
53323       catch(std::out_of_range &_e) {
53324         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53325         return 0;
53326       }
53327
53328     } CALL_CATCH_EXCEPTION(0);
53329   }
53330
53331   jresult = new Dali::Actor((const Dali::Actor &)result);
53332   return jresult;
53333 }
53334
53335
53336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
53337   void * jresult ;
53338   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53339   int arg2 ;
53340   Dali::Actor *result = 0 ;
53341
53342   arg1 = (std::vector< Dali::Actor > *)jarg1;
53343   arg2 = (int)jarg2;
53344   {
53345     try {
53346       try {
53347         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
53348       }
53349       catch(std::out_of_range &_e) {
53350         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53351         return 0;
53352       }
53353
53354     } CALL_CATCH_EXCEPTION(0);
53355   }
53356
53357   jresult = (void *)result;
53358   return jresult;
53359 }
53360
53361
53362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
53363   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53364   int arg2 ;
53365   Dali::Actor *arg3 = 0 ;
53366
53367   arg1 = (std::vector< Dali::Actor > *)jarg1;
53368   arg2 = (int)jarg2;
53369   arg3 = (Dali::Actor *)jarg3;
53370   if (!arg3) {
53371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
53372     return ;
53373   }
53374   {
53375     try {
53376       try {
53377         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
53378       }
53379       catch(std::out_of_range &_e) {
53380         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53381         return ;
53382       }
53383
53384     } CALL_CATCH_EXCEPTION();
53385   }
53386
53387 }
53388
53389
53390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
53391   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53392   std::vector< Dali::Actor > *arg2 = 0 ;
53393
53394   arg1 = (std::vector< Dali::Actor > *)jarg1;
53395   arg2 = (std::vector< Dali::Actor > *)jarg2;
53396   if (!arg2) {
53397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
53398     return ;
53399   }
53400   {
53401     try {
53402       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
53403     } CALL_CATCH_EXCEPTION();
53404   }
53405
53406 }
53407
53408
53409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
53410   void * jresult ;
53411   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53412   int arg2 ;
53413   int arg3 ;
53414   std::vector< Dali::Actor > *result = 0 ;
53415
53416   arg1 = (std::vector< Dali::Actor > *)jarg1;
53417   arg2 = (int)jarg2;
53418   arg3 = (int)jarg3;
53419   {
53420     try {
53421       try {
53422         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
53423       }
53424       catch(std::out_of_range &_e) {
53425         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53426         return 0;
53427       }
53428       catch(std::invalid_argument &_e) {
53429         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
53430         return 0;
53431       }
53432
53433     } CALL_CATCH_EXCEPTION(0);
53434   }
53435
53436   jresult = (void *)result;
53437   return jresult;
53438 }
53439
53440
53441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
53442   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53443   int arg2 ;
53444   Dali::Actor *arg3 = 0 ;
53445
53446   arg1 = (std::vector< Dali::Actor > *)jarg1;
53447   arg2 = (int)jarg2;
53448   arg3 = (Dali::Actor *)jarg3;
53449   if (!arg3) {
53450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
53451     return ;
53452   }
53453   {
53454     try {
53455       try {
53456         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
53457       }
53458       catch(std::out_of_range &_e) {
53459         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53460         return ;
53461       }
53462
53463     } CALL_CATCH_EXCEPTION();
53464   }
53465
53466 }
53467
53468
53469 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
53470   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53471   int arg2 ;
53472   std::vector< Dali::Actor > *arg3 = 0 ;
53473
53474   arg1 = (std::vector< Dali::Actor > *)jarg1;
53475   arg2 = (int)jarg2;
53476   arg3 = (std::vector< Dali::Actor > *)jarg3;
53477   if (!arg3) {
53478     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
53479     return ;
53480   }
53481   {
53482     try {
53483       try {
53484         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
53485       }
53486       catch(std::out_of_range &_e) {
53487         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53488         return ;
53489       }
53490
53491     } CALL_CATCH_EXCEPTION();
53492   }
53493
53494 }
53495
53496
53497 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
53498   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53499   int arg2 ;
53500
53501   arg1 = (std::vector< Dali::Actor > *)jarg1;
53502   arg2 = (int)jarg2;
53503   {
53504     try {
53505       try {
53506         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
53507       }
53508       catch(std::out_of_range &_e) {
53509         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53510         return ;
53511       }
53512
53513     } CALL_CATCH_EXCEPTION();
53514   }
53515
53516 }
53517
53518
53519 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
53520   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53521   int arg2 ;
53522   int arg3 ;
53523
53524   arg1 = (std::vector< Dali::Actor > *)jarg1;
53525   arg2 = (int)jarg2;
53526   arg3 = (int)jarg3;
53527   {
53528     try {
53529       try {
53530         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
53531       }
53532       catch(std::out_of_range &_e) {
53533         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53534         return ;
53535       }
53536       catch(std::invalid_argument &_e) {
53537         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
53538         return ;
53539       }
53540
53541     } CALL_CATCH_EXCEPTION();
53542   }
53543
53544 }
53545
53546
53547 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
53548   void * jresult ;
53549   Dali::Actor *arg1 = 0 ;
53550   int arg2 ;
53551   std::vector< Dali::Actor > *result = 0 ;
53552
53553   arg1 = (Dali::Actor *)jarg1;
53554   if (!arg1) {
53555     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
53556     return 0;
53557   }
53558   arg2 = (int)jarg2;
53559   {
53560     try {
53561       try {
53562         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
53563       }
53564       catch(std::out_of_range &_e) {
53565         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53566         return 0;
53567       }
53568
53569     } CALL_CATCH_EXCEPTION(0);
53570   }
53571
53572   jresult = (void *)result;
53573   return jresult;
53574 }
53575
53576
53577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
53578   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53579
53580   arg1 = (std::vector< Dali::Actor > *)jarg1;
53581   {
53582     try {
53583       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
53584     } CALL_CATCH_EXCEPTION();
53585   }
53586
53587 }
53588
53589
53590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
53591   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53592   int arg2 ;
53593   int arg3 ;
53594
53595   arg1 = (std::vector< Dali::Actor > *)jarg1;
53596   arg2 = (int)jarg2;
53597   arg3 = (int)jarg3;
53598   {
53599     try {
53600       try {
53601         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
53602       }
53603       catch(std::out_of_range &_e) {
53604         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53605         return ;
53606       }
53607       catch(std::invalid_argument &_e) {
53608         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
53609         return ;
53610       }
53611
53612     } CALL_CATCH_EXCEPTION();
53613   }
53614
53615 }
53616
53617
53618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
53619   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53620   int arg2 ;
53621   std::vector< Dali::Actor > *arg3 = 0 ;
53622
53623   arg1 = (std::vector< Dali::Actor > *)jarg1;
53624   arg2 = (int)jarg2;
53625   arg3 = (std::vector< Dali::Actor > *)jarg3;
53626   if (!arg3) {
53627     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
53628     return ;
53629   }
53630   {
53631     try {
53632       try {
53633         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
53634       }
53635       catch(std::out_of_range &_e) {
53636         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53637         return ;
53638       }
53639
53640     } CALL_CATCH_EXCEPTION();
53641   }
53642
53643 }
53644
53645
53646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
53647   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53648
53649   arg1 = (std::vector< Dali::Actor > *)jarg1;
53650   {
53651     try {
53652       delete arg1;
53653     } CALL_CATCH_EXCEPTION();
53654   }
53655
53656 }
53657
53658
53659 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
53660   unsigned int jresult ;
53661   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
53662   bool result;
53663
53664   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
53665   {
53666     try {
53667       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
53668     } CALL_CATCH_EXCEPTION(0);
53669   }
53670
53671   jresult = result;
53672   return jresult;
53673 }
53674
53675
53676 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
53677   unsigned long jresult ;
53678   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
53679   std::size_t result;
53680
53681   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
53682   {
53683     try {
53684       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
53685     } CALL_CATCH_EXCEPTION(0);
53686   }
53687
53688   jresult = (unsigned long)result;
53689   return jresult;
53690 }
53691
53692
53693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
53694   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
53695   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
53696
53697   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
53698   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
53699   {
53700     try {
53701       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
53702     } CALL_CATCH_EXCEPTION();
53703   }
53704
53705 }
53706
53707
53708 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
53709   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
53710   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
53711
53712   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
53713   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
53714   {
53715     try {
53716       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
53717     } CALL_CATCH_EXCEPTION();
53718   }
53719
53720 }
53721
53722
53723 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
53724   unsigned int jresult ;
53725   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
53726   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
53727   bool result;
53728
53729   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
53730   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
53731   if (!arg2) {
53732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
53733     return 0;
53734   }
53735   {
53736     try {
53737       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
53738     } CALL_CATCH_EXCEPTION(0);
53739   }
53740
53741   jresult = result;
53742   return jresult;
53743 }
53744
53745
53746 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
53747   void * jresult ;
53748   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
53749
53750   {
53751     try {
53752       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
53753     } CALL_CATCH_EXCEPTION(0);
53754   }
53755
53756   jresult = (void *)result;
53757   return jresult;
53758 }
53759
53760
53761 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
53762   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
53763
53764   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
53765   {
53766     try {
53767       delete arg1;
53768     } CALL_CATCH_EXCEPTION();
53769   }
53770
53771 }
53772
53773
53774 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
53775   unsigned int jresult ;
53776   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
53777   bool result;
53778
53779   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
53780   {
53781     try {
53782       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);
53783     } CALL_CATCH_EXCEPTION(0);
53784   }
53785
53786   jresult = result;
53787   return jresult;
53788 }
53789
53790
53791 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
53792   unsigned long jresult ;
53793   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
53794   std::size_t result;
53795
53796   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
53797   {
53798     try {
53799       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);
53800     } CALL_CATCH_EXCEPTION(0);
53801   }
53802
53803   jresult = (unsigned long)result;
53804   return jresult;
53805 }
53806
53807
53808 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
53809   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
53810   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
53811
53812   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
53813   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
53814   {
53815     try {
53816       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
53817     } CALL_CATCH_EXCEPTION();
53818   }
53819
53820 }
53821
53822
53823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
53824   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
53825   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
53826
53827   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
53828   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
53829   {
53830     try {
53831       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
53832     } CALL_CATCH_EXCEPTION();
53833   }
53834
53835 }
53836
53837
53838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
53839   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
53840   Dali::Actor arg2 ;
53841   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
53842   Dali::Actor *argp2 ;
53843
53844   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
53845   argp2 = (Dali::Actor *)jarg2;
53846   if (!argp2) {
53847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
53848     return ;
53849   }
53850   arg2 = *argp2;
53851   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
53852   {
53853     try {
53854       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
53855     } CALL_CATCH_EXCEPTION();
53856   }
53857
53858 }
53859
53860
53861 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
53862   void * jresult ;
53863   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
53864
53865   {
53866     try {
53867       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
53868     } CALL_CATCH_EXCEPTION(0);
53869   }
53870
53871   jresult = (void *)result;
53872   return jresult;
53873 }
53874
53875
53876 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
53877   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
53878
53879   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
53880   {
53881     try {
53882       delete arg1;
53883     } CALL_CATCH_EXCEPTION();
53884   }
53885
53886 }
53887
53888
53889 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
53890   unsigned int jresult ;
53891   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
53892   bool result;
53893
53894   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
53895   {
53896     try {
53897       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
53898     } CALL_CATCH_EXCEPTION(0);
53899   }
53900
53901   jresult = result;
53902   return jresult;
53903 }
53904
53905
53906 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
53907   unsigned long jresult ;
53908   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
53909   std::size_t result;
53910
53911   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
53912   {
53913     try {
53914       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
53915     } CALL_CATCH_EXCEPTION(0);
53916   }
53917
53918   jresult = (unsigned long)result;
53919   return jresult;
53920 }
53921
53922
53923 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
53924   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
53925   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
53926
53927   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
53928   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
53929   {
53930     try {
53931       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
53932     } CALL_CATCH_EXCEPTION();
53933   }
53934
53935 }
53936
53937
53938 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
53939   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
53940   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
53941
53942   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
53943   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
53944   {
53945     try {
53946       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
53947     } CALL_CATCH_EXCEPTION();
53948   }
53949
53950 }
53951
53952
53953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
53954   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
53955   Dali::Actor arg2 ;
53956   Dali::Actor arg3 ;
53957   Dali::Actor *argp2 ;
53958   Dali::Actor *argp3 ;
53959
53960   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
53961   argp2 = (Dali::Actor *)jarg2;
53962   if (!argp2) {
53963     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
53964     return ;
53965   }
53966   arg2 = *argp2;
53967   argp3 = (Dali::Actor *)jarg3;
53968   if (!argp3) {
53969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
53970     return ;
53971   }
53972   arg3 = *argp3;
53973   {
53974     try {
53975       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
53976     } CALL_CATCH_EXCEPTION();
53977   }
53978
53979 }
53980
53981
53982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
53983   void * jresult ;
53984   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
53985
53986   {
53987     try {
53988       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
53989     } CALL_CATCH_EXCEPTION(0);
53990   }
53991
53992   jresult = (void *)result;
53993   return jresult;
53994 }
53995
53996
53997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
53998   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
53999
54000   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
54001   {
54002     try {
54003       delete arg1;
54004     } CALL_CATCH_EXCEPTION();
54005   }
54006
54007 }
54008
54009
54010 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
54011   unsigned int jresult ;
54012   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
54013   bool result;
54014
54015   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
54016   {
54017     try {
54018       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
54019     } CALL_CATCH_EXCEPTION(0);
54020   }
54021
54022   jresult = result;
54023   return jresult;
54024 }
54025
54026
54027 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
54028   unsigned long jresult ;
54029   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
54030   std::size_t result;
54031
54032   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
54033   {
54034     try {
54035       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
54036     } CALL_CATCH_EXCEPTION(0);
54037   }
54038
54039   jresult = (unsigned long)result;
54040   return jresult;
54041 }
54042
54043
54044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
54045   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
54046   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
54047
54048   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
54049   arg2 = (void (*)(Dali::Actor,bool))jarg2;
54050   {
54051     try {
54052       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
54053     } CALL_CATCH_EXCEPTION();
54054   }
54055
54056 }
54057
54058
54059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
54060   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
54061   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
54062
54063   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
54064   arg2 = (void (*)(Dali::Actor,bool))jarg2;
54065   {
54066     try {
54067       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
54068     } CALL_CATCH_EXCEPTION();
54069   }
54070
54071 }
54072
54073
54074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
54075   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
54076   Dali::Actor arg2 ;
54077   bool arg3 ;
54078   Dali::Actor *argp2 ;
54079
54080   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
54081   argp2 = (Dali::Actor *)jarg2;
54082   if (!argp2) {
54083     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
54084     return ;
54085   }
54086   arg2 = *argp2;
54087   arg3 = jarg3 ? true : false;
54088   {
54089     try {
54090       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
54091     } CALL_CATCH_EXCEPTION();
54092   }
54093
54094 }
54095
54096
54097 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
54098   void * jresult ;
54099   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
54100
54101   {
54102     try {
54103       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
54104     } CALL_CATCH_EXCEPTION(0);
54105   }
54106
54107   jresult = (void *)result;
54108   return jresult;
54109 }
54110
54111
54112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
54113   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
54114
54115   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
54116   {
54117     try {
54118       delete arg1;
54119     } CALL_CATCH_EXCEPTION();
54120   }
54121
54122 }
54123
54124
54125 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
54126   unsigned int jresult ;
54127   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
54128   bool result;
54129
54130   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
54131   {
54132     try {
54133       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);
54134     } CALL_CATCH_EXCEPTION(0);
54135   }
54136
54137   jresult = result;
54138   return jresult;
54139 }
54140
54141
54142 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
54143   unsigned long jresult ;
54144   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
54145   std::size_t result;
54146
54147   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
54148   {
54149     try {
54150       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);
54151     } CALL_CATCH_EXCEPTION(0);
54152   }
54153
54154   jresult = (unsigned long)result;
54155   return jresult;
54156 }
54157
54158
54159 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
54160   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
54161   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
54162
54163   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
54164   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
54165   {
54166     try {
54167       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
54168     } CALL_CATCH_EXCEPTION();
54169   }
54170
54171 }
54172
54173
54174 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
54175   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
54176   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
54177
54178   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
54179   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
54180   {
54181     try {
54182       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
54183     } CALL_CATCH_EXCEPTION();
54184   }
54185
54186 }
54187
54188
54189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
54190   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
54191   Dali::Toolkit::StyleManager arg2 ;
54192   Dali::StyleChange::Type arg3 ;
54193   Dali::Toolkit::StyleManager *argp2 ;
54194
54195   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
54196   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
54197   if (!argp2) {
54198     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
54199     return ;
54200   }
54201   arg2 = *argp2;
54202   arg3 = (Dali::StyleChange::Type)jarg3;
54203   {
54204     try {
54205       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
54206     } CALL_CATCH_EXCEPTION();
54207   }
54208
54209 }
54210
54211
54212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
54213   void * jresult ;
54214   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
54215
54216   {
54217     try {
54218       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
54219     } CALL_CATCH_EXCEPTION(0);
54220   }
54221
54222   jresult = (void *)result;
54223   return jresult;
54224 }
54225
54226
54227 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
54228   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
54229
54230   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
54231   {
54232     try {
54233       delete arg1;
54234     } CALL_CATCH_EXCEPTION();
54235   }
54236
54237 }
54238
54239
54240 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
54241   unsigned int jresult ;
54242   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
54243   bool result;
54244
54245   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
54246   {
54247     try {
54248       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
54249     } CALL_CATCH_EXCEPTION(0);
54250   }
54251
54252   jresult = result;
54253   return jresult;
54254 }
54255
54256
54257 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
54258   unsigned long jresult ;
54259   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
54260   std::size_t result;
54261
54262   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
54263   {
54264     try {
54265       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
54266     } CALL_CATCH_EXCEPTION(0);
54267   }
54268
54269   jresult = (unsigned long)result;
54270   return jresult;
54271 }
54272
54273
54274 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
54275   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
54276   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
54277
54278   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
54279   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
54280   {
54281     try {
54282       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
54283     } CALL_CATCH_EXCEPTION();
54284   }
54285
54286 }
54287
54288
54289 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
54290   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
54291   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
54292
54293   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
54294   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
54295   {
54296     try {
54297       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
54298     } CALL_CATCH_EXCEPTION();
54299   }
54300
54301 }
54302
54303
54304 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
54305   unsigned int jresult ;
54306   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
54307   Dali::Toolkit::Button arg2 ;
54308   Dali::Toolkit::Button *argp2 ;
54309   bool result;
54310
54311   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
54312   argp2 = (Dali::Toolkit::Button *)jarg2;
54313   if (!argp2) {
54314     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
54315     return 0;
54316   }
54317   arg2 = *argp2;
54318   {
54319     try {
54320       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
54321     } CALL_CATCH_EXCEPTION(0);
54322   }
54323
54324   jresult = result;
54325   return jresult;
54326 }
54327
54328
54329 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
54330   void * jresult ;
54331   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
54332
54333   {
54334     try {
54335       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
54336     } CALL_CATCH_EXCEPTION(0);
54337   }
54338
54339   jresult = (void *)result;
54340   return jresult;
54341 }
54342
54343
54344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
54345   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
54346
54347   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
54348   {
54349     try {
54350       delete arg1;
54351     } CALL_CATCH_EXCEPTION();
54352   }
54353
54354 }
54355
54356
54357 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
54358   unsigned int jresult ;
54359   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
54360   bool result;
54361
54362   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
54363   {
54364     try {
54365       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
54366     } CALL_CATCH_EXCEPTION(0);
54367   }
54368
54369   jresult = result;
54370   return jresult;
54371 }
54372
54373
54374 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
54375   unsigned long jresult ;
54376   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
54377   std::size_t result;
54378
54379   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
54380   {
54381     try {
54382       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
54383     } CALL_CATCH_EXCEPTION(0);
54384   }
54385
54386   jresult = (unsigned long)result;
54387   return jresult;
54388 }
54389
54390
54391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
54392   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
54393   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
54394
54395   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
54396   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
54397   {
54398     try {
54399       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
54400     } CALL_CATCH_EXCEPTION();
54401   }
54402
54403 }
54404
54405
54406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
54407   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
54408   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
54409
54410   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
54411   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
54412   {
54413     try {
54414       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
54415     } CALL_CATCH_EXCEPTION();
54416   }
54417
54418 }
54419
54420
54421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
54422   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
54423   Dali::Toolkit::GaussianBlurView arg2 ;
54424   Dali::Toolkit::GaussianBlurView *argp2 ;
54425
54426   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
54427   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
54428   if (!argp2) {
54429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
54430     return ;
54431   }
54432   arg2 = *argp2;
54433   {
54434     try {
54435       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
54436     } CALL_CATCH_EXCEPTION();
54437   }
54438
54439 }
54440
54441
54442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
54443   void * jresult ;
54444   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
54445
54446   {
54447     try {
54448       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
54449     } CALL_CATCH_EXCEPTION(0);
54450   }
54451
54452   jresult = (void *)result;
54453   return jresult;
54454 }
54455
54456
54457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
54458   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
54459
54460   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
54461   {
54462     try {
54463       delete arg1;
54464     } CALL_CATCH_EXCEPTION();
54465   }
54466
54467 }
54468
54469
54470 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
54471   unsigned int jresult ;
54472   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
54473   bool result;
54474
54475   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
54476   {
54477     try {
54478       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);
54479     } CALL_CATCH_EXCEPTION(0);
54480   }
54481
54482   jresult = result;
54483   return jresult;
54484 }
54485
54486
54487 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
54488   unsigned long jresult ;
54489   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
54490   std::size_t result;
54491
54492   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
54493   {
54494     try {
54495       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);
54496     } CALL_CATCH_EXCEPTION(0);
54497   }
54498
54499   jresult = (unsigned long)result;
54500   return jresult;
54501 }
54502
54503
54504 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
54505   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
54506   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
54507
54508   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
54509   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
54510   {
54511     try {
54512       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
54513     } CALL_CATCH_EXCEPTION();
54514   }
54515
54516 }
54517
54518
54519 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
54520   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
54521   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
54522
54523   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
54524   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
54525   {
54526     try {
54527       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
54528     } CALL_CATCH_EXCEPTION();
54529   }
54530
54531 }
54532
54533
54534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
54535   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
54536   Dali::Toolkit::PageTurnView arg2 ;
54537   unsigned int arg3 ;
54538   bool arg4 ;
54539   Dali::Toolkit::PageTurnView *argp2 ;
54540
54541   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
54542   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
54543   if (!argp2) {
54544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
54545     return ;
54546   }
54547   arg2 = *argp2;
54548   arg3 = (unsigned int)jarg3;
54549   arg4 = jarg4 ? true : false;
54550   {
54551     try {
54552       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
54553     } CALL_CATCH_EXCEPTION();
54554   }
54555
54556 }
54557
54558
54559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
54560   void * jresult ;
54561   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
54562
54563   {
54564     try {
54565       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
54566     } CALL_CATCH_EXCEPTION(0);
54567   }
54568
54569   jresult = (void *)result;
54570   return jresult;
54571 }
54572
54573
54574 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
54575   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
54576
54577   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
54578   {
54579     try {
54580       delete arg1;
54581     } CALL_CATCH_EXCEPTION();
54582   }
54583
54584 }
54585
54586
54587 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
54588   unsigned int jresult ;
54589   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
54590   bool result;
54591
54592   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
54593   {
54594     try {
54595       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
54596     } CALL_CATCH_EXCEPTION(0);
54597   }
54598
54599   jresult = result;
54600   return jresult;
54601 }
54602
54603
54604 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
54605   unsigned long jresult ;
54606   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
54607   std::size_t result;
54608
54609   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
54610   {
54611     try {
54612       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
54613     } CALL_CATCH_EXCEPTION(0);
54614   }
54615
54616   jresult = (unsigned long)result;
54617   return jresult;
54618 }
54619
54620
54621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
54622   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
54623   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
54624
54625   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
54626   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
54627   {
54628     try {
54629       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
54630     } CALL_CATCH_EXCEPTION();
54631   }
54632 }
54633
54634
54635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
54636   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
54637   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
54638
54639   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
54640   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
54641   {
54642     try {
54643       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
54644     } CALL_CATCH_EXCEPTION();
54645   }
54646 }
54647
54648
54649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
54650   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
54651   Dali::Toolkit::PageTurnView arg2 ;
54652   Dali::Toolkit::PageTurnView *argp2 ;
54653
54654   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
54655   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
54656   if (!argp2) {
54657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
54658     return ;
54659   }
54660   arg2 = *argp2;
54661   {
54662     try {
54663       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
54664     } CALL_CATCH_EXCEPTION();
54665   }
54666 }
54667
54668
54669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
54670   void * jresult ;
54671   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
54672
54673   {
54674     try {
54675       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
54676     } CALL_CATCH_EXCEPTION(0);
54677   }
54678
54679   jresult = (void *)result;
54680   return jresult;
54681 }
54682
54683
54684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
54685   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
54686
54687   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
54688   {
54689     try {
54690       delete arg1;
54691     } CALL_CATCH_EXCEPTION();
54692   }
54693
54694 }
54695
54696
54697 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
54698   unsigned int jresult ;
54699   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
54700   bool result;
54701
54702   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
54703   {
54704     try {
54705       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);
54706     } CALL_CATCH_EXCEPTION(0);
54707   }
54708
54709   jresult = result;
54710   return jresult;
54711 }
54712
54713
54714 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
54715   unsigned long jresult ;
54716   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
54717   std::size_t result;
54718
54719   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
54720   {
54721     try {
54722       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);
54723     } CALL_CATCH_EXCEPTION(0);
54724   }
54725
54726   jresult = (unsigned long)result;
54727   return jresult;
54728 }
54729
54730
54731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
54732   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
54733   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
54734
54735   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
54736   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
54737   {
54738     try {
54739       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
54740     } CALL_CATCH_EXCEPTION();
54741   }
54742
54743 }
54744
54745
54746 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
54747   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
54748   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
54749
54750   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
54751   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
54752   {
54753     try {
54754       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
54755     } CALL_CATCH_EXCEPTION();
54756   }
54757
54758 }
54759
54760
54761 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
54762   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
54763   Dali::Toolkit::ProgressBar arg2 ;
54764   float arg3 ;
54765   float arg4 ;
54766   Dali::Toolkit::ProgressBar *argp2 ;
54767
54768   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
54769   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
54770   if (!argp2) {
54771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
54772     return ;
54773   }
54774   arg2 = *argp2;
54775   arg3 = (float)jarg3;
54776   arg4 = (float)jarg4;
54777   {
54778     try {
54779       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
54780     } CALL_CATCH_EXCEPTION();
54781   }
54782
54783 }
54784
54785
54786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
54787   void * jresult ;
54788   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
54789
54790   {
54791     try {
54792       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
54793     } CALL_CATCH_EXCEPTION(0);
54794   }
54795
54796   jresult = (void *)result;
54797   return jresult;
54798 }
54799
54800
54801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
54802   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
54803
54804   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
54805   {
54806     try {
54807       delete arg1;
54808     } CALL_CATCH_EXCEPTION();
54809   }
54810
54811 }
54812
54813
54814 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
54815   unsigned int jresult ;
54816   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
54817   bool result;
54818
54819   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
54820   {
54821     try {
54822       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);
54823     } CALL_CATCH_EXCEPTION(0);
54824   }
54825
54826   jresult = result;
54827   return jresult;
54828 }
54829
54830
54831 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
54832   unsigned long jresult ;
54833   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
54834   std::size_t result;
54835
54836   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
54837   {
54838     try {
54839       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);
54840     } CALL_CATCH_EXCEPTION(0);
54841   }
54842
54843   jresult = (unsigned long)result;
54844   return jresult;
54845 }
54846
54847
54848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
54849   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
54850   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
54851
54852   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
54853   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
54854   {
54855     try {
54856       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
54857     } CALL_CATCH_EXCEPTION();
54858   }
54859
54860 }
54861
54862
54863 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
54864   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
54865   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
54866
54867   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
54868   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
54869   {
54870     try {
54871       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
54872     } CALL_CATCH_EXCEPTION();
54873   }
54874
54875 }
54876
54877
54878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
54879   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
54880   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
54881
54882   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
54883   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
54884   if (!arg2) {
54885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
54886     return ;
54887   }
54888   {
54889     try {
54890       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
54891     } CALL_CATCH_EXCEPTION();
54892   }
54893
54894 }
54895
54896
54897 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
54898   void * jresult ;
54899   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
54900
54901   {
54902     try {
54903       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
54904     } CALL_CATCH_EXCEPTION(0);
54905   }
54906
54907   jresult = (void *)result;
54908   return jresult;
54909 }
54910
54911
54912 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
54913   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
54914
54915   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
54916   {
54917     try {
54918       delete arg1;
54919     } CALL_CATCH_EXCEPTION();
54920   }
54921
54922 }
54923
54924
54925 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
54926   unsigned int jresult ;
54927   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
54928   bool result;
54929
54930   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
54931   {
54932     try {
54933       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
54934     } CALL_CATCH_EXCEPTION(0);
54935   }
54936
54937   jresult = result;
54938   return jresult;
54939 }
54940
54941
54942 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
54943   unsigned long jresult ;
54944   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
54945   std::size_t result;
54946
54947   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
54948   {
54949     try {
54950       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
54951     } CALL_CATCH_EXCEPTION(0);
54952   }
54953
54954   jresult = (unsigned long)result;
54955   return jresult;
54956 }
54957
54958
54959 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
54960   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
54961   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
54962
54963   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
54964   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
54965   {
54966     try {
54967       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
54968     } CALL_CATCH_EXCEPTION();
54969   }
54970
54971 }
54972
54973
54974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
54975   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
54976   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
54977
54978   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
54979   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
54980   {
54981     try {
54982       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
54983     } CALL_CATCH_EXCEPTION();
54984   }
54985
54986 }
54987
54988
54989 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
54990   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
54991   Dali::Vector2 *arg2 = 0 ;
54992
54993   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
54994   arg2 = (Dali::Vector2 *)jarg2;
54995   if (!arg2) {
54996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
54997     return ;
54998   }
54999   {
55000     try {
55001       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
55002     } CALL_CATCH_EXCEPTION();
55003   }
55004
55005 }
55006
55007
55008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
55009   void * jresult ;
55010   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
55011
55012   {
55013     try {
55014       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
55015     } CALL_CATCH_EXCEPTION(0);
55016   }
55017
55018   jresult = (void *)result;
55019   return jresult;
55020 }
55021
55022
55023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
55024   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
55025
55026   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
55027   {
55028     try {
55029       delete arg1;
55030     } CALL_CATCH_EXCEPTION();
55031   }
55032
55033 }
55034
55035
55036
55037 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
55038   unsigned int jresult ;
55039   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
55040   bool result;
55041
55042   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
55043   {
55044     try {
55045       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);
55046     } CALL_CATCH_EXCEPTION(0);
55047   }
55048
55049   jresult = result;
55050   return jresult;
55051 }
55052
55053
55054 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
55055   unsigned long jresult ;
55056   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
55057   std::size_t result;
55058
55059   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
55060   {
55061     try {
55062       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);
55063     } CALL_CATCH_EXCEPTION(0);
55064   }
55065
55066   jresult = (unsigned long)result;
55067   return jresult;
55068 }
55069
55070
55071 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
55072   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
55073   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
55074
55075   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
55076   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
55077   {
55078     try {
55079       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55080     } CALL_CATCH_EXCEPTION();
55081   }
55082
55083 }
55084
55085
55086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
55087   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
55088   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
55089
55090   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
55091   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
55092   {
55093     try {
55094       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55095     } CALL_CATCH_EXCEPTION();
55096   }
55097
55098 }
55099
55100
55101 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55102   unsigned int jresult ;
55103   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
55104   Dali::Toolkit::Control arg2 ;
55105   Dali::KeyEvent *arg3 = 0 ;
55106   Dali::Toolkit::Control *argp2 ;
55107   bool result;
55108
55109   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
55110   argp2 = (Dali::Toolkit::Control *)jarg2;
55111   if (!argp2) {
55112     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
55113     return 0;
55114   }
55115   arg2 = *argp2;
55116   arg3 = (Dali::KeyEvent *)jarg3;
55117   if (!arg3) {
55118     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
55119     return 0;
55120   }
55121   {
55122     try {
55123       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);
55124     } CALL_CATCH_EXCEPTION(0);
55125   }
55126
55127   jresult = result;
55128   return jresult;
55129 }
55130
55131
55132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
55133   void * jresult ;
55134   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
55135
55136   {
55137     try {
55138       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
55139     } CALL_CATCH_EXCEPTION(0);
55140   }
55141
55142   jresult = (void *)result;
55143   return jresult;
55144 }
55145
55146
55147 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
55148   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
55149
55150   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
55151   {
55152     try {
55153       delete arg1;
55154     } CALL_CATCH_EXCEPTION();
55155   }
55156
55157 }
55158
55159
55160 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
55161   unsigned int jresult ;
55162   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
55163   bool result;
55164
55165   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
55166   {
55167     try {
55168       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
55169     } CALL_CATCH_EXCEPTION(0);
55170   }
55171
55172   jresult = result;
55173   return jresult;
55174 }
55175
55176
55177 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
55178   unsigned long jresult ;
55179   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
55180   std::size_t result;
55181
55182   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
55183   {
55184     try {
55185       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
55186     } CALL_CATCH_EXCEPTION(0);
55187   }
55188
55189   jresult = (unsigned long)result;
55190   return jresult;
55191 }
55192
55193
55194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
55195   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
55196   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
55197
55198   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
55199   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
55200   {
55201     try {
55202       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
55203     } CALL_CATCH_EXCEPTION();
55204   }
55205
55206 }
55207
55208
55209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
55210   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
55211   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
55212
55213   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
55214   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
55215   {
55216     try {
55217       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
55218     } CALL_CATCH_EXCEPTION();
55219   }
55220
55221 }
55222
55223
55224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
55225   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
55226   Dali::Toolkit::Control arg2 ;
55227   Dali::Toolkit::Control *argp2 ;
55228
55229   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
55230   argp2 = (Dali::Toolkit::Control *)jarg2;
55231   if (!argp2) {
55232     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
55233     return ;
55234   }
55235   arg2 = *argp2;
55236   {
55237     try {
55238       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
55239     } CALL_CATCH_EXCEPTION();
55240   }
55241
55242 }
55243
55244
55245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
55246   void * jresult ;
55247   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
55248
55249   {
55250     try {
55251       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
55252     } CALL_CATCH_EXCEPTION(0);
55253   }
55254
55255   jresult = (void *)result;
55256   return jresult;
55257 }
55258
55259
55260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
55261   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
55262
55263   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
55264   {
55265     try {
55266       delete arg1;
55267     } CALL_CATCH_EXCEPTION();
55268   }
55269
55270 }
55271
55272
55273 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
55274   unsigned int jresult ;
55275   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
55276   bool result;
55277
55278   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
55279   {
55280     try {
55281       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
55282     } CALL_CATCH_EXCEPTION(0);
55283   }
55284
55285   jresult = result;
55286   return jresult;
55287 }
55288
55289
55290 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
55291   unsigned long jresult ;
55292   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
55293   std::size_t result;
55294
55295   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
55296   {
55297     try {
55298       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
55299     } CALL_CATCH_EXCEPTION(0);
55300   }
55301
55302   jresult = (unsigned long)result;
55303   return jresult;
55304 }
55305
55306
55307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
55308   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
55309   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
55310
55311   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
55312   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
55313   {
55314     try {
55315       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
55316     } CALL_CATCH_EXCEPTION();
55317   }
55318
55319 }
55320
55321
55322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
55323   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
55324   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
55325
55326   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
55327   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
55328   {
55329     try {
55330       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
55331     } CALL_CATCH_EXCEPTION();
55332   }
55333
55334 }
55335
55336
55337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
55338   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
55339   Dali::Toolkit::VideoView *arg2 = 0 ;
55340
55341   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
55342   arg2 = (Dali::Toolkit::VideoView *)jarg2;
55343   if (!arg2) {
55344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
55345     return ;
55346   }
55347   {
55348     try {
55349       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
55350     } CALL_CATCH_EXCEPTION();
55351   }
55352
55353 }
55354
55355
55356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
55357   void * jresult ;
55358   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
55359
55360   {
55361     try {
55362       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
55363     } CALL_CATCH_EXCEPTION(0);
55364   }
55365
55366   jresult = (void *)result;
55367   return jresult;
55368 }
55369
55370
55371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
55372   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
55373
55374   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
55375   {
55376     try {
55377       delete arg1;
55378     } CALL_CATCH_EXCEPTION();
55379   }
55380
55381 }
55382
55383
55384 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
55385   unsigned int jresult ;
55386   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
55387   bool result;
55388
55389   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
55390   {
55391     try {
55392       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
55393     } CALL_CATCH_EXCEPTION(0);
55394   }
55395
55396   jresult = result;
55397   return jresult;
55398 }
55399
55400
55401 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
55402   unsigned long jresult ;
55403   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
55404   std::size_t result;
55405
55406   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
55407   {
55408     try {
55409       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
55410     } CALL_CATCH_EXCEPTION(0);
55411   }
55412
55413   jresult = (unsigned long)result;
55414   return jresult;
55415 }
55416
55417
55418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
55419   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
55420   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
55421
55422   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
55423   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
55424   {
55425     try {
55426       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
55427     } CALL_CATCH_EXCEPTION();
55428   }
55429
55430 }
55431
55432
55433 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
55434   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
55435   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
55436
55437   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
55438   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
55439   {
55440     try {
55441       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
55442     } CALL_CATCH_EXCEPTION();
55443   }
55444
55445 }
55446
55447
55448 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
55449   unsigned int jresult ;
55450   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
55451   Dali::Toolkit::Slider arg2 ;
55452   float arg3 ;
55453   Dali::Toolkit::Slider *argp2 ;
55454   bool result;
55455
55456   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
55457   argp2 = (Dali::Toolkit::Slider *)jarg2;
55458   if (!argp2) {
55459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
55460     return 0;
55461   }
55462   arg2 = *argp2;
55463   arg3 = (float)jarg3;
55464   {
55465     try {
55466       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
55467     } CALL_CATCH_EXCEPTION(0);
55468   }
55469
55470   jresult = result;
55471   return jresult;
55472 }
55473
55474
55475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
55476   void * jresult ;
55477   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
55478
55479   {
55480     try {
55481       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
55482     } CALL_CATCH_EXCEPTION(0);
55483   }
55484
55485   jresult = (void *)result;
55486   return jresult;
55487 }
55488
55489
55490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
55491   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
55492
55493   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
55494   {
55495     try {
55496       delete arg1;
55497     } CALL_CATCH_EXCEPTION();
55498   }
55499
55500 }
55501
55502
55503 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
55504   unsigned int jresult ;
55505   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
55506   bool result;
55507
55508   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
55509   {
55510     try {
55511       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
55512     } CALL_CATCH_EXCEPTION(0);
55513   }
55514
55515   jresult = result;
55516   return jresult;
55517 }
55518
55519
55520 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
55521   unsigned long jresult ;
55522   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
55523   std::size_t result;
55524
55525   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
55526   {
55527     try {
55528       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
55529     } CALL_CATCH_EXCEPTION(0);
55530   }
55531
55532   jresult = (unsigned long)result;
55533   return jresult;
55534 }
55535
55536
55537 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
55538   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
55539   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
55540
55541   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
55542   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
55543   {
55544     try {
55545       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
55546     } CALL_CATCH_EXCEPTION();
55547   }
55548
55549 }
55550
55551
55552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
55553   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
55554   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
55555
55556   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
55557   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
55558   {
55559     try {
55560       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
55561     } CALL_CATCH_EXCEPTION();
55562   }
55563
55564 }
55565
55566
55567 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
55568   unsigned int jresult ;
55569   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
55570   Dali::Toolkit::Slider arg2 ;
55571   int arg3 ;
55572   Dali::Toolkit::Slider *argp2 ;
55573   bool result;
55574
55575   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
55576   argp2 = (Dali::Toolkit::Slider *)jarg2;
55577   if (!argp2) {
55578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
55579     return 0;
55580   }
55581   arg2 = *argp2;
55582   arg3 = (int)jarg3;
55583   {
55584     try {
55585       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
55586     } CALL_CATCH_EXCEPTION(0);
55587   }
55588
55589   jresult = result;
55590   return jresult;
55591 }
55592
55593
55594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
55595   void * jresult ;
55596   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
55597
55598   {
55599     try {
55600       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
55601     } CALL_CATCH_EXCEPTION(0);
55602   }
55603
55604   jresult = (void *)result;
55605   return jresult;
55606 }
55607
55608
55609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
55610   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
55611
55612   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
55613   {
55614     try {
55615       delete arg1;
55616     } CALL_CATCH_EXCEPTION();
55617   }
55618
55619 }
55620
55621
55622 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
55623   void * jresult ;
55624   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
55625
55626   {
55627     try {
55628       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
55629     } CALL_CATCH_EXCEPTION(0);
55630   }
55631
55632   jresult = (void *)result;
55633   return jresult;
55634 }
55635
55636
55637 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
55638   void * jresult ;
55639   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
55640   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
55641
55642   arg1 = (Dali::Toolkit::Ruler *)jarg1;
55643   {
55644     try {
55645       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
55646     } CALL_CATCH_EXCEPTION(0);
55647   }
55648
55649   jresult = (void *)result;
55650   return jresult;
55651 }
55652
55653
55654 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
55655   void * jresult ;
55656   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
55657   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
55658
55659   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55660   if (!arg1) {
55661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
55662     return 0;
55663   }
55664   {
55665     try {
55666       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
55667     } CALL_CATCH_EXCEPTION(0);
55668   }
55669
55670   jresult = (void *)result;
55671   return jresult;
55672 }
55673
55674
55675 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
55676   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55677
55678   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55679   {
55680     try {
55681       delete arg1;
55682     } CALL_CATCH_EXCEPTION();
55683   }
55684
55685 }
55686
55687
55688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
55689   void * jresult ;
55690   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55691   Dali::Toolkit::Ruler *result = 0 ;
55692
55693   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55694   {
55695     try {
55696       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
55697     } CALL_CATCH_EXCEPTION(0);
55698   }
55699
55700   jresult = (void *)result;
55701   return jresult;
55702 }
55703
55704
55705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
55706   void * jresult ;
55707   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55708   Dali::Toolkit::Ruler *result = 0 ;
55709
55710   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55711   {
55712     try {
55713       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
55714     } CALL_CATCH_EXCEPTION(0);
55715   }
55716
55717   jresult = (void *)result;
55718   return jresult;
55719 }
55720
55721
55722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
55723   void * jresult ;
55724   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55725   Dali::Toolkit::Ruler *result = 0 ;
55726
55727   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55728   {
55729     try {
55730       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
55731     } CALL_CATCH_EXCEPTION(0);
55732   }
55733
55734   jresult = (void *)result;
55735   return jresult;
55736 }
55737
55738
55739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
55740   void * jresult ;
55741   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55742   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
55743   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
55744
55745   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55746   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
55747   if (!arg2) {
55748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
55749     return 0;
55750   }
55751   {
55752     try {
55753       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
55754     } CALL_CATCH_EXCEPTION(0);
55755   }
55756
55757   jresult = (void *)result;
55758   return jresult;
55759 }
55760
55761
55762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
55763   void * jresult ;
55764   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55765   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
55766   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
55767
55768   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55769   arg2 = (Dali::Toolkit::Ruler *)jarg2;
55770   {
55771     try {
55772       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
55773     } CALL_CATCH_EXCEPTION(0);
55774   }
55775
55776   jresult = (void *)result;
55777   return jresult;
55778 }
55779
55780
55781 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
55782   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55783
55784   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55785   {
55786     try {
55787       (arg1)->Reset();
55788     } CALL_CATCH_EXCEPTION();
55789   }
55790
55791 }
55792
55793
55794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
55795   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55796   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
55797
55798   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55799   arg2 = (Dali::Toolkit::Ruler *)jarg2;
55800   {
55801     try {
55802       (arg1)->Reset(arg2);
55803     } CALL_CATCH_EXCEPTION();
55804   }
55805
55806 }
55807
55808
55809 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
55810   void * jresult ;
55811   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55812   Dali::Toolkit::Ruler *result = 0 ;
55813
55814   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55815   {
55816     try {
55817       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
55818     } CALL_CATCH_EXCEPTION(0);
55819   }
55820
55821   jresult = (void *)result;
55822   return jresult;
55823 }
55824
55825
55826 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
55827   float jresult ;
55828   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55829   float arg2 ;
55830   float arg3 ;
55831   float result;
55832
55833   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55834   arg2 = (float)jarg2;
55835   arg3 = (float)jarg3;
55836   {
55837     try {
55838       result = (float)(*arg1)->Snap(arg2,arg3);
55839     } CALL_CATCH_EXCEPTION(0);
55840   }
55841
55842   jresult = result;
55843   return jresult;
55844 }
55845
55846
55847 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
55848   float jresult ;
55849   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55850   float arg2 ;
55851   float result;
55852
55853   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55854   arg2 = (float)jarg2;
55855   {
55856     try {
55857       result = (float)(*arg1)->Snap(arg2);
55858     } CALL_CATCH_EXCEPTION(0);
55859   }
55860
55861   jresult = result;
55862   return jresult;
55863 }
55864
55865
55866 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
55867   float jresult ;
55868   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55869   unsigned int arg2 ;
55870   unsigned int *arg3 = 0 ;
55871   bool arg4 ;
55872   float result;
55873
55874   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55875   arg2 = (unsigned int)jarg2;
55876   arg3 = (unsigned int *)jarg3;
55877   arg4 = jarg4 ? true : false;
55878   {
55879     try {
55880       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
55881     } CALL_CATCH_EXCEPTION(0);
55882   }
55883
55884   jresult = result;
55885   return jresult;
55886 }
55887
55888
55889 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
55890   unsigned int jresult ;
55891   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55892   float arg2 ;
55893   bool arg3 ;
55894   unsigned int result;
55895
55896   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55897   arg2 = (float)jarg2;
55898   arg3 = jarg3 ? true : false;
55899   {
55900     try {
55901       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
55902     } CALL_CATCH_EXCEPTION(0);
55903   }
55904
55905   jresult = result;
55906   return jresult;
55907 }
55908
55909
55910 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
55911   unsigned int jresult ;
55912   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55913   unsigned int result;
55914
55915   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55916   {
55917     try {
55918       result = (unsigned int)(*arg1)->GetTotalPages();
55919     } CALL_CATCH_EXCEPTION(0);
55920   }
55921
55922   jresult = result;
55923   return jresult;
55924 }
55925
55926
55927 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
55928   int jresult ;
55929   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55930   Dali::Toolkit::Ruler::RulerType result;
55931
55932   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55933   {
55934     try {
55935       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
55936     } CALL_CATCH_EXCEPTION(0);
55937   }
55938
55939   jresult = (int)result;
55940   return jresult;
55941 }
55942
55943
55944 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
55945   unsigned int jresult ;
55946   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55947   bool result;
55948
55949   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55950   {
55951     try {
55952       result = (bool)(*arg1)->IsEnabled();
55953     } CALL_CATCH_EXCEPTION(0);
55954   }
55955
55956   jresult = result;
55957   return jresult;
55958 }
55959
55960
55961 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
55962   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55963
55964   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55965   {
55966     try {
55967       (*arg1)->Enable();
55968     } CALL_CATCH_EXCEPTION();
55969   }
55970
55971 }
55972
55973
55974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
55975   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55976
55977   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55978   {
55979     try {
55980       (*arg1)->Disable();
55981     } CALL_CATCH_EXCEPTION();
55982   }
55983
55984 }
55985
55986
55987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
55988   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55989   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
55990   Dali::Toolkit::RulerDomain *argp2 ;
55991
55992   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55993   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
55994   if (!argp2) {
55995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
55996     return ;
55997   }
55998   arg2 = *argp2;
55999   {
56000     try {
56001       (*arg1)->SetDomain(arg2);
56002     } CALL_CATCH_EXCEPTION();
56003   }
56004
56005 }
56006
56007
56008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
56009   void * jresult ;
56010   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
56011   Dali::Toolkit::RulerDomain *result = 0 ;
56012
56013   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
56014   {
56015     try {
56016       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
56017     } CALL_CATCH_EXCEPTION(0);
56018   }
56019
56020   jresult = (void *)result;
56021   return jresult;
56022 }
56023
56024
56025 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
56026   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
56027
56028   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
56029   {
56030     try {
56031       (*arg1)->DisableDomain();
56032     } CALL_CATCH_EXCEPTION();
56033   }
56034
56035 }
56036
56037
56038 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
56039   float jresult ;
56040   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
56041   float arg2 ;
56042   float arg3 ;
56043   float arg4 ;
56044   float result;
56045
56046   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
56047   arg2 = (float)jarg2;
56048   arg3 = (float)jarg3;
56049   arg4 = (float)jarg4;
56050   {
56051     try {
56052       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
56053     } CALL_CATCH_EXCEPTION(0);
56054   }
56055
56056   jresult = result;
56057   return jresult;
56058 }
56059
56060
56061 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
56062   float jresult ;
56063   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
56064   float arg2 ;
56065   float arg3 ;
56066   float result;
56067
56068   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
56069   arg2 = (float)jarg2;
56070   arg3 = (float)jarg3;
56071   {
56072     try {
56073       result = (float)(*arg1)->Clamp(arg2,arg3);
56074     } CALL_CATCH_EXCEPTION(0);
56075   }
56076
56077   jresult = result;
56078   return jresult;
56079 }
56080
56081
56082 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
56083   float jresult ;
56084   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
56085   float arg2 ;
56086   float result;
56087
56088   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
56089   arg2 = (float)jarg2;
56090   {
56091     try {
56092       result = (float)(*arg1)->Clamp(arg2);
56093     } CALL_CATCH_EXCEPTION(0);
56094   }
56095
56096   jresult = result;
56097   return jresult;
56098 }
56099
56100
56101 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
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   Dali::Toolkit::ClampState *arg5 = 0 ;
56108   float result;
56109
56110   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
56111   arg2 = (float)jarg2;
56112   arg3 = (float)jarg3;
56113   arg4 = (float)jarg4;
56114   arg5 = (Dali::Toolkit::ClampState *)jarg5;
56115   if (!arg5) {
56116     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
56117     return 0;
56118   }
56119   {
56120     try {
56121       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
56122     } CALL_CATCH_EXCEPTION(0);
56123   }
56124
56125   jresult = result;
56126   return jresult;
56127 }
56128
56129
56130 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
56131   float jresult ;
56132   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
56133   float arg2 ;
56134   float arg3 ;
56135   float arg4 ;
56136   float arg5 ;
56137   float result;
56138
56139   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
56140   arg2 = (float)jarg2;
56141   arg3 = (float)jarg3;
56142   arg4 = (float)jarg4;
56143   arg5 = (float)jarg5;
56144   {
56145     try {
56146       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
56147     } CALL_CATCH_EXCEPTION(0);
56148   }
56149
56150   jresult = result;
56151   return jresult;
56152 }
56153
56154
56155 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
56156   float jresult ;
56157   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
56158   float arg2 ;
56159   float arg3 ;
56160   float arg4 ;
56161   float result;
56162
56163   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
56164   arg2 = (float)jarg2;
56165   arg3 = (float)jarg3;
56166   arg4 = (float)jarg4;
56167   {
56168     try {
56169       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
56170     } CALL_CATCH_EXCEPTION(0);
56171   }
56172
56173   jresult = result;
56174   return jresult;
56175 }
56176
56177
56178 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
56179   float jresult ;
56180   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
56181   float arg2 ;
56182   float arg3 ;
56183   float result;
56184
56185   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
56186   arg2 = (float)jarg2;
56187   arg3 = (float)jarg3;
56188   {
56189     try {
56190       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
56191     } CALL_CATCH_EXCEPTION(0);
56192   }
56193
56194   jresult = result;
56195   return jresult;
56196 }
56197
56198
56199 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
56200   float jresult ;
56201   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
56202   float arg2 ;
56203   float result;
56204
56205   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
56206   arg2 = (float)jarg2;
56207   {
56208     try {
56209       result = (float)(*arg1)->SnapAndClamp(arg2);
56210     } CALL_CATCH_EXCEPTION(0);
56211   }
56212
56213   jresult = result;
56214   return jresult;
56215 }
56216
56217
56218 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
56219   float jresult ;
56220   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
56221   float arg2 ;
56222   float arg3 ;
56223   float arg4 ;
56224   float arg5 ;
56225   Dali::Toolkit::ClampState *arg6 = 0 ;
56226   float result;
56227
56228   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
56229   arg2 = (float)jarg2;
56230   arg3 = (float)jarg3;
56231   arg4 = (float)jarg4;
56232   arg5 = (float)jarg5;
56233   arg6 = (Dali::Toolkit::ClampState *)jarg6;
56234   if (!arg6) {
56235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
56236     return 0;
56237   }
56238   {
56239     try {
56240       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
56241     } CALL_CATCH_EXCEPTION(0);
56242   }
56243
56244   jresult = result;
56245   return jresult;
56246 }
56247
56248
56249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
56250   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
56251
56252   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
56253   {
56254     try {
56255       (*arg1)->Reference();
56256     } CALL_CATCH_EXCEPTION();
56257   }
56258
56259 }
56260
56261
56262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
56263   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
56264
56265   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
56266   {
56267     try {
56268       (*arg1)->Unreference();
56269     } CALL_CATCH_EXCEPTION();
56270   }
56271
56272 }
56273
56274
56275 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
56276   int jresult ;
56277   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
56278   int result;
56279
56280   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
56281   {
56282     try {
56283       result = (int)(*arg1)->ReferenceCount();
56284     } CALL_CATCH_EXCEPTION(0);
56285   }
56286
56287   jresult = result;
56288   return jresult;
56289 }
56290
56291
56292 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Empty(void * jarg1) {
56293   unsigned int jresult ;
56294   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
56295   bool result;
56296
56297   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
56298   {
56299     try {
56300       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
56301     } CALL_CATCH_EXCEPTION(0);
56302   }
56303
56304   jresult = result;
56305   return jresult;
56306 }
56307
56308
56309 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_GetConnectionCount(void * jarg1) {
56310   unsigned long jresult ;
56311   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
56312   std::size_t result;
56313
56314   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
56315   {
56316     try {
56317       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
56318     } CALL_CATCH_EXCEPTION(0);
56319   }
56320
56321   jresult = (unsigned long)result;
56322   return jresult;
56323 }
56324
56325
56326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Connect(void * jarg1, void * jarg2) {
56327   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
56328   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
56329
56330   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
56331   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
56332   {
56333     try {
56334       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
56335     } CALL_CATCH_EXCEPTION();
56336   }
56337
56338 }
56339
56340
56341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Disconnect(void * jarg1, void * jarg2) {
56342   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
56343   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
56344
56345   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
56346   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
56347   {
56348     try {
56349       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
56350     } CALL_CATCH_EXCEPTION();
56351   }
56352
56353 }
56354
56355
56356 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Emit(void * jarg1, void * jarg2) {
56357   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
56358   Dali::Toolkit::Control arg2 ;
56359   Dali::Toolkit::Control *argp2 ;
56360
56361   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
56362   argp2 = (Dali::Toolkit::Control *)jarg2;
56363   if (!argp2) {
56364     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
56365     return ;
56366   }
56367   arg2 = *argp2;
56368   {
56369     try {
56370       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
56371     } CALL_CATCH_EXCEPTION();
56372   }
56373
56374 }
56375
56376
56377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewResourceReadySignal() {
56378   void * jresult ;
56379   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
56380
56381   {
56382     try {
56383       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
56384     } CALL_CATCH_EXCEPTION(0);
56385   }
56386
56387   jresult = (void *)result;
56388   return jresult;
56389 }
56390
56391
56392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewResourceReadySignal(void * jarg1) {
56393   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
56394
56395   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
56396   {
56397     try {
56398       delete arg1;
56399     } CALL_CATCH_EXCEPTION();
56400   }
56401
56402 }
56403
56404 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_GetRefObjectPtr(Dali::BaseHandle *arg1) {
56405   Dali::RefObject *result = NULL;
56406
56407   if (arg1)
56408   {
56409     result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
56410   }
56411   return result;
56412 }
56413
56414 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
56415     return (Dali::RefObject *)jarg1;
56416 }
56417
56418 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
56419     return (Dali::SignalObserver *)jarg1;
56420 }
56421
56422 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
56423     return (Dali::ConnectionTrackerInterface *)jarg1;
56424 }
56425
56426 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
56427     return (Dali::BaseHandle *)jarg1;
56428 }
56429
56430 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
56431     return (Dali::BaseHandle *)jarg1;
56432 }
56433
56434 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
56435     return (Dali::BaseHandle *)jarg1;
56436 }
56437
56438 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
56439     return (Dali::BaseHandle *)jarg1;
56440 }
56441
56442 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
56443     return (Dali::BaseHandle *)jarg1;
56444 }
56445
56446 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
56447     return (Dali::BaseHandle *)jarg1;
56448 }
56449
56450 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
56451     return (Dali::BaseHandle *)jarg1;
56452 }
56453
56454 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
56455     return (Dali::BaseHandle *)jarg1;
56456 }
56457
56458 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
56459     return (Dali::BaseHandle *)jarg1;
56460 }
56461
56462 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
56463     return (Dali::BaseHandle *)jarg1;
56464 }
56465
56466 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VertexBuffer_SWIGUpcast(Dali::VertexBuffer *jarg1) {
56467     return (Dali::BaseHandle *)jarg1;
56468 }
56469
56470 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
56471     return (Dali::BaseHandle *)jarg1;
56472 }
56473
56474 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
56475     return (Dali::Handle *)jarg1;
56476 }
56477
56478 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
56479     return (Dali::Handle *)jarg1;
56480 }
56481
56482 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
56483     return (Dali::BaseHandle *)jarg1;
56484 }
56485
56486 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
56487     return (Dali::BaseHandle *)jarg1;
56488 }
56489
56490 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
56491     return (Dali::Handle *)jarg1;
56492 }
56493
56494 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchEvent *jarg1) {
56495     return (Dali::BaseHandle *)jarg1;
56496 }
56497
56498 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Hover_SWIGUpcast(Dali::HoverEvent *jarg1) {
56499     return (Dali::BaseHandle *)jarg1;
56500 }
56501
56502 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Wheel_SWIGUpcast(Dali::WheelEvent *jarg1) {
56503     return (Dali::BaseHandle *)jarg1;
56504 }
56505
56506 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Key_SWIGUpcast(Dali::KeyEvent *jarg1) {
56507     return (Dali::BaseHandle *)jarg1;
56508 }
56509
56510 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
56511     return (Dali::Handle *)jarg1;
56512 }
56513
56514 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
56515     return (Dali::GestureDetector *)jarg1;
56516 }
56517
56518 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
56519     return (Dali::Gesture *)jarg1;
56520 }
56521
56522 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
56523     return (Dali::Handle *)jarg1;
56524 }
56525
56526 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
56527     return (Dali::Actor *)jarg1;
56528 }
56529
56530 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
56531     return (Dali::RefObject *)jarg1;
56532 }
56533
56534 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
56535     return (Dali::Actor *)jarg1;
56536 }
56537
56538 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
56539     return (Dali::GestureDetector *)jarg1;
56540 }
56541
56542 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
56543     return (Dali::Gesture *)jarg1;
56544 }
56545
56546 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
56547     return (Dali::GestureDetector *)jarg1;
56548 }
56549
56550 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
56551     return (Dali::Gesture *)jarg1;
56552 }
56553
56554 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
56555     return (Dali::GestureDetector *)jarg1;
56556 }
56557
56558 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
56559     return (Dali::Gesture *)jarg1;
56560 }
56561
56562 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
56563     return (Dali::BaseHandle *)jarg1;
56564 }
56565
56566 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
56567     return (Dali::Handle *)jarg1;
56568 }
56569
56570 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
56571     return (Dali::Handle *)jarg1;
56572 }
56573
56574 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
56575     return (Dali::Handle *)jarg1;
56576 }
56577
56578 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
56579     return (Dali::RefObject *)jarg1;
56580 }
56581
56582 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
56583     return (Dali::Actor *)jarg1;
56584 }
56585
56586 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
56587     return (Dali::BaseHandle *)jarg1;
56588 }
56589
56590 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
56591     return (Dali::BaseHandle *)jarg1;
56592 }
56593
56594 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
56595     return (Dali::BaseHandle *)jarg1;
56596 }
56597
56598 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
56599     return (Dali::CustomActorImpl *)jarg1;
56600 }
56601
56602 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
56603     return (Dali::CustomActor *)jarg1;
56604 }
56605
56606 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
56607     return (Dali::BaseHandle *)jarg1;
56608 }
56609
56610 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
56611     return (Dali::Toolkit::Control *)jarg1;
56612 }
56613
56614 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
56615     return (Dali::Toolkit::Control *)jarg1;
56616 }
56617
56618 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
56619     return (Dali::Toolkit::Button *)jarg1;
56620 }
56621
56622 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
56623     return (Dali::Toolkit::Button *)jarg1;
56624 }
56625
56626 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
56627     return (Dali::Toolkit::Button *)jarg1;
56628 }
56629
56630 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
56631     return (Dali::Toolkit::Control *)jarg1;
56632 }
56633
56634 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
56635     return (Dali::Toolkit::Control *)jarg1;
56636 }
56637
56638 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
56639     return (Dali::Toolkit::Control *)jarg1;
56640 }
56641
56642 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
56643     return (Dali::Toolkit::Control *)jarg1;
56644 }
56645
56646 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
56647     return (Dali::Toolkit::Control *)jarg1;
56648 }
56649
56650 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
56651     return (Dali::RefObject *)jarg1;
56652 }
56653
56654 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
56655     return (Dali::Toolkit::Scrollable *)jarg1;
56656 }
56657
56658 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
56659     return (Dali::BaseHandle *)jarg1;
56660 }
56661
56662 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
56663     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
56664 }
56665
56666 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
56667     return (Dali::RefObject *)jarg1;
56668 }
56669
56670 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
56671     return (Dali::Toolkit::Ruler *)jarg1;
56672 }
56673
56674 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
56675     return (Dali::Toolkit::Ruler *)jarg1;
56676 }
56677
56678 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
56679     return (Dali::Toolkit::Scrollable *)jarg1;
56680 }
56681
56682 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
56683     return (Dali::Toolkit::Control *)jarg1;
56684 }
56685
56686
56687 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
56688     return (Dali::Toolkit::Control *)jarg1;
56689 }
56690
56691 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
56692     return (Dali::BaseHandle *)jarg1;
56693 }
56694
56695 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
56696     return (Dali::BaseHandle *)jarg1;
56697 }
56698
56699 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
56700     return (Dali::Toolkit::Control *)jarg1;
56701 }
56702
56703 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
56704     return (Dali::Toolkit::Control *)jarg1;
56705 }
56706
56707 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
56708     return (Dali::Toolkit::Control *)jarg1;
56709 }
56710
56711 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
56712     return (Dali::Toolkit::Control *)jarg1;
56713 }
56714
56715 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
56716     return (Dali::Toolkit::Control *)jarg1;
56717 }
56718
56719 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
56720     return (Dali::Toolkit::Control *)jarg1;
56721 }
56722
56723 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
56724     return (Dali::Toolkit::PageTurnView *)jarg1;
56725 }
56726
56727 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
56728     return (Dali::Toolkit::PageTurnView *)jarg1;
56729 }
56730
56731 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
56732     return (Dali::Toolkit::Button *)jarg1;
56733 }
56734
56735 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
56736     return (Dali::BaseHandle *)jarg1;
56737 }
56738
56739 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
56740     return (Dali::BaseHandle *)jarg1;
56741 }
56742
56743 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
56744     return (Dali::BaseHandle *)jarg1;
56745 }
56746
56747 /*
56748  * Widget binding
56749  */
56750 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Widget_SWIGUpcast(Dali::Widget *jarg1) {
56751     return (Dali::BaseHandle *)jarg1;
56752 }
56753
56754 SWIGEXPORT Dali::BaseObject * SWIGSTDCALL CSharp_Dali_WidgetImpl_SWIGUpcast(Dali::Internal::Adaptor::Widget *jarg1) {
56755     return (Dali::BaseObject *)jarg1;
56756 }
56757
56758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_0() {
56759   void * jresult ;
56760   Dali::Widget result;
56761
56762   {
56763     try {
56764       result = Dali::Widget::New();
56765     } CALL_CATCH_EXCEPTION(0);
56766   }
56767
56768   jresult = new Dali::Widget((const Dali::Widget &)result);
56769   return jresult;
56770 }
56771
56772
56773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_1(void * jarg1) {
56774   void * jresult ;
56775   Dali::Internal::Adaptor::Widget *arg1 = 0 ;
56776   Dali::Widget result;
56777
56778   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
56779
56780   if (!arg1) {
56781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Internal::Adaptor::Widget & type is null", 0);
56782     return 0;
56783   }
56784   {
56785     try {
56786       jresult = new Dali::Widget(arg1);
56787     } CALL_CATCH_EXCEPTION(0);
56788   }
56789   return jresult;
56790 }
56791
56792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Widget() {
56793   void * jresult ;
56794   Dali::Widget *result = 0 ;
56795
56796   {
56797     try {
56798       result = (Dali::Widget *)new Dali::Widget();
56799     } CALL_CATCH_EXCEPTION(0);
56800   }
56801   jresult = (void *)result;
56802   return jresult;
56803 }
56804
56805
56806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_Assign(void * jarg1, void * jarg2) {
56807   void * jresult ;
56808   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
56809   Dali::Widget *arg2 = 0 ;
56810   Dali::Widget *result = 0 ;
56811
56812   arg1 = (Dali::Widget *)jarg1;
56813   arg2 = (Dali::Widget *)jarg2;
56814   if (!arg2) {
56815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget const & type is null", 0);
56816     return 0;
56817   }
56818   {
56819     try {
56820       result = (Dali::Widget *) &(arg1)->operator =((Dali::Widget const &)*arg2);
56821     } CALL_CATCH_EXCEPTION(0);
56822   }
56823   jresult = (void *)result;
56824   return jresult;
56825 }
56826
56827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Widget(void * jarg1) {
56828   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
56829
56830   arg1 = (Dali::Widget *)jarg1;
56831   {
56832     try {
56833       delete arg1;
56834     } CALL_CATCH_EXCEPTION();
56835   }
56836 }
56837
56838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetImpl_New() {
56839   void * jresult ;
56840   SwigDirector_WidgetImpl* result;
56841   {
56842     try {
56843       result = new SwigDirector_WidgetImpl();
56844     } CALL_CATCH_EXCEPTION(0);
56845   }
56846   jresult = result;
56847   return jresult;
56848 }
56849
56850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreate(void * jarg1, char * jarg2, void * jarg3) {
56851   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
56852   std::string *arg2 = 0 ;
56853   Dali::Window arg3 ;
56854   Dali::Window *argp3 ;
56855
56856   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
56857   if (!jarg2) {
56858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
56859     return ;
56860   }
56861   std::string arg2_str(jarg2);
56862   arg2 = &arg2_str;
56863   argp3 = (Dali::Window *)jarg3;
56864   if (!argp3) {
56865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
56866     return ;
56867   }
56868   arg3 = *argp3;
56869   {
56870     try {
56871       (arg1)->OnCreate((std::string const &)*arg2,arg3);
56872     } CALL_CATCH_EXCEPTION();
56873   }
56874 }
56875
56876
56877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, void * jarg3) {
56878   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
56879   std::string *arg2 = 0 ;
56880   Dali::Window arg3 ;
56881   Dali::Window *argp3 ;
56882
56883   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
56884   if (!jarg2) {
56885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
56886     return ;
56887   }
56888   std::string arg2_str(jarg2);
56889   arg2 = &arg2_str;
56890   argp3 = (Dali::Window *)jarg3;
56891   if (!argp3) {
56892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
56893     return ;
56894   }
56895   arg3 = *argp3;
56896   {
56897     try {
56898       (arg1)->Dali::Internal::Adaptor::Widget::OnCreate((std::string const &)*arg2,arg3);
56899     } CALL_CATCH_EXCEPTION();
56900   }
56901 }
56902
56903
56904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminate(void * jarg1, char * jarg2, int jarg3) {
56905   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
56906   std::string *arg2 = 0 ;
56907   Dali::Widget::Termination arg3 ;
56908
56909   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
56910   if (!jarg2) {
56911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
56912     return ;
56913   }
56914   std::string arg2_str(jarg2);
56915   arg2 = &arg2_str;
56916   arg3 = (Dali::Widget::Termination)jarg3;
56917   {
56918     try {
56919       (arg1)->OnTerminate((std::string const &)*arg2,arg3);
56920     } CALL_CATCH_EXCEPTION();
56921   }
56922 }
56923
56924
56925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
56926   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
56927   std::string *arg2 = 0 ;
56928   Dali::Widget::Termination arg3 ;
56929
56930   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
56931   if (!jarg2) {
56932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
56933     return ;
56934   }
56935   std::string arg2_str(jarg2);
56936   arg2 = &arg2_str;
56937   arg3 = (Dali::Widget::Termination)jarg3;
56938   {
56939     try {
56940       (arg1)->Dali::Internal::Adaptor::Widget::OnTerminate((std::string const &)*arg2,arg3);
56941     } CALL_CATCH_EXCEPTION();
56942   }
56943 }
56944
56945
56946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPause(void * jarg1) {
56947   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
56948
56949   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
56950   {
56951     try {
56952       (arg1)->OnPause();
56953     } CALL_CATCH_EXCEPTION();
56954   }
56955 }
56956
56957
56958 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPauseSwigExplicitWidgetImpl(void * jarg1) {
56959   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
56960
56961   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
56962   {
56963     try {
56964       (arg1)->Dali::Internal::Adaptor::Widget::OnPause();
56965     } CALL_CATCH_EXCEPTION();
56966   }
56967 }
56968
56969
56970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResume(void * jarg1) {
56971   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
56972
56973   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
56974   {
56975     try {
56976       (arg1)->OnResume();
56977     } CALL_CATCH_EXCEPTION();
56978   }
56979 }
56980
56981
56982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResumeSwigExplicitWidgetImpl(void * jarg1) {
56983   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
56984
56985   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
56986   {
56987     try {
56988       (arg1)->Dali::Internal::Adaptor::Widget::OnResume();
56989     } CALL_CATCH_EXCEPTION();
56990   }
56991 }
56992
56993
56994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResize(void * jarg1, void * jarg2) {
56995   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
56996   Dali::Window arg2 ;
56997   Dali::Window *argp2 ;
56998
56999   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
57000   argp2 = (Dali::Window *)jarg2;
57001   if (!argp2) {
57002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
57003     return ;
57004   }
57005   arg2 = *argp2;
57006   {
57007     try {
57008       (arg1)->OnResize(arg2);
57009     } CALL_CATCH_EXCEPTION();
57010   }
57011 }
57012
57013
57014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResizeSwigExplicitWidgetImpl(void * jarg1, void * jarg2) {
57015   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
57016   Dali::Window arg2 ;
57017   Dali::Window *argp2 ;
57018
57019   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
57020   argp2 = (Dali::Window *)jarg2;
57021   if (!argp2) {
57022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
57023     return ;
57024   }
57025   arg2 = *argp2;
57026   {
57027     try {
57028       (arg1)->Dali::Internal::Adaptor::Widget::OnResize(arg2);
57029     } CALL_CATCH_EXCEPTION();
57030   }
57031 }
57032
57033
57034 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdate(void * jarg1, char * jarg2, int jarg3) {
57035   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
57036   std::string *arg2 = 0 ;
57037   int arg3 ;
57038
57039   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
57040   if (!jarg2) {
57041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57042     return ;
57043   }
57044   std::string arg2_str(jarg2);
57045   arg2 = &arg2_str;
57046   arg3 = (int)jarg3;
57047   {
57048     try {
57049       (arg1)->OnUpdate((std::string const &)*arg2,arg3);
57050     } CALL_CATCH_EXCEPTION();
57051   }
57052 }
57053
57054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
57055   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
57056   std::string *arg2 = 0 ;
57057   int arg3 ;
57058
57059   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
57060   if (!jarg2) {
57061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57062     return ;
57063   }
57064   std::string arg2_str(jarg2);
57065   arg2 = &arg2_str;
57066   arg3 = (int)jarg3;
57067   {
57068     try {
57069       (arg1)->Dali::Internal::Adaptor::Widget::OnUpdate((std::string const &)*arg2,arg3);
57070     } CALL_CATCH_EXCEPTION();
57071   }
57072 }
57073
57074
57075 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
57076   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
57077   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
57078   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
57079
57080   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
57081   arg2 = (Dali::SlotObserver *)jarg2;
57082   arg3 = (Dali::CallbackBase *)jarg3;
57083   {
57084     try {
57085       (arg1)->SignalConnected(arg2,arg3);
57086     } CALL_CATCH_EXCEPTION();
57087   }
57088 }
57089
57090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
57091   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
57092   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
57093   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
57094
57095   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
57096   arg2 = (Dali::SlotObserver *)jarg2;
57097   arg3 = (Dali::CallbackBase *)jarg3;
57098   {
57099     try {
57100       (arg1)->Dali::Internal::Adaptor::Widget::SignalConnected(arg2,arg3);
57101     } CALL_CATCH_EXCEPTION();
57102   }
57103 }
57104
57105
57106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
57107   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
57108   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
57109   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
57110
57111   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
57112   arg2 = (Dali::SlotObserver *)jarg2;
57113   arg3 = (Dali::CallbackBase *)jarg3;
57114   {
57115     try {
57116       (arg1)->SignalDisconnected(arg2,arg3);
57117     } CALL_CATCH_EXCEPTION();
57118   }
57119 }
57120
57121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
57122   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
57123   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
57124   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
57125
57126   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
57127   arg2 = (Dali::SlotObserver *)jarg2;
57128   arg3 = (Dali::CallbackBase *)jarg3;
57129   {
57130     try {
57131       (arg1)->Dali::Internal::Adaptor::Widget::SignalDisconnected(arg2,arg3);
57132     } CALL_CATCH_EXCEPTION();
57133   }
57134 }
57135
57136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetContentInfo(void * jarg1, char * jarg2) {
57137   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
57138   std::string *arg2 = 0 ;
57139
57140   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
57141   if (!jarg2) {
57142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57143     return ;
57144   }
57145   std::string arg2_str(jarg2);
57146   arg2 = &arg2_str;
57147   {
57148     try {
57149       (arg1)->SetContentInfo((std::string const &)*arg2);
57150     } CALL_CATCH_EXCEPTION();
57151   }
57152 }
57153
57154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetImpl(void * jarg1, void * jarg2) {
57155   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
57156   Dali::Internal::Adaptor::Widget::Impl *arg2 = (Dali::Internal::Adaptor::Widget::Impl *) 0 ;
57157
57158   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
57159   arg2 = (Dali::Internal::Adaptor::Widget::Impl *)jarg2;
57160   {
57161     try {
57162       (arg1)->SetImpl(arg2);
57163     } CALL_CATCH_EXCEPTION();
57164   }
57165 }
57166
57167
57168 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) {
57169   SwigDirector_WidgetImpl *director = static_cast<SwigDirector_WidgetImpl *>(objarg);
57170   if (director) {
57171     director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback7);
57172   }
57173 }
57174
57175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_GetImplementation__SWIG_0(void * jarg1) {
57176   void * jresult ;
57177   Dali::Widget *arg1 = 0 ;
57178   SwigDirector_WidgetImpl *result = 0 ;
57179
57180   arg1 = (Dali::Widget *)jarg1;
57181   if (!arg1) {
57182     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget & type is null", 0);
57183     return 0;
57184   }
57185   {
57186     try {
57187       result = (SwigDirector_WidgetImpl *) &Dali::Internal::Adaptor::GetImplementation(*arg1);
57188     } CALL_CATCH_EXCEPTION(0);
57189   }
57190   jresult = (void*) result;
57191   return jresult;
57192 }
57193
57194
57195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_New(int jarg1, char * jarg2, char * jarg3) {
57196   void * jresult ;
57197   int *arg1 = (int *) 0 ;
57198   char ***arg2 ;
57199   std::string *arg3 = 0 ;
57200   Dali::WidgetApplication result;
57201   {
57202     int index = 0;
57203     int length = 0;
57204     char *retPtr;
57205     char *nextPtr;
57206     argWidgetC = jarg1;
57207     argWidgetV = new char*[jarg1 + 1];
57208
57209     retPtr = strtok_r( jarg2, " ", &nextPtr);
57210     if( retPtr )
57211     {
57212       length = strlen(retPtr);
57213     }
57214     argWidgetV[index] = new char[length + 1];
57215     if( retPtr )
57216     {
57217       strncpy(argWidgetV[index], retPtr, length);
57218     }
57219     argWidgetV[index][length] = '\0';
57220     index++;
57221
57222     while (index < jarg1)
57223     {
57224       length = 0;
57225       retPtr = strtok_r(NULL, " ", &nextPtr);
57226       if( retPtr )
57227       {
57228         length = strlen(retPtr);
57229       }
57230       argWidgetV[index] = new char[length + 1];
57231       if( retPtr )
57232       {
57233         strncpy(argWidgetV[index], retPtr, length);
57234       }
57235       argWidgetV[index][length] = '\0';
57236       index++;
57237     }
57238
57239     argWidgetV[jarg1] = NULL;
57240     argWidgetC = jarg1;
57241
57242     arg1 = &argWidgetC;
57243     arg2 = &argWidgetV;
57244   }
57245
57246   if (!jarg3) {
57247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57248     return 0;
57249   }
57250   std::string arg3_str(jarg3);
57251   arg3 = &arg3_str;
57252   {
57253     try {
57254       result = Dali::WidgetApplication::New(arg1,arg2,(std::string const &)*arg3);
57255     } CALL_CATCH_EXCEPTION(0);
57256   }
57257   jresult = new Dali::WidgetApplication((const Dali::WidgetApplication &)result);
57258   return jresult;
57259 }
57260
57261
57262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_0() {
57263   void * jresult ;
57264   Dali::WidgetApplication *result = 0 ;
57265
57266   {
57267     try {
57268       result = (Dali::WidgetApplication *)new Dali::WidgetApplication();
57269     } CALL_CATCH_EXCEPTION(0);
57270   }
57271   jresult = (void *)result;
57272   return jresult;
57273 }
57274
57275
57276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_1(void * jarg1) {
57277   void * jresult ;
57278   Dali::WidgetApplication *arg1 = 0 ;
57279   Dali::WidgetApplication *result = 0 ;
57280
57281   arg1 = (Dali::WidgetApplication *)jarg1;
57282   if (!arg1) {
57283     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
57284     return 0;
57285   }
57286   {
57287     try {
57288       result = (Dali::WidgetApplication *)new Dali::WidgetApplication((Dali::WidgetApplication const &)*arg1);
57289     } CALL_CATCH_EXCEPTION(0);
57290   }
57291   jresult = (void *)result;
57292   return jresult;
57293 }
57294
57295
57296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_Assign(void * jarg1, void * jarg2) {
57297   void * jresult ;
57298   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
57299   Dali::WidgetApplication *arg2 = 0 ;
57300   Dali::WidgetApplication *result = 0 ;
57301
57302   arg1 = (Dali::WidgetApplication *)jarg1;
57303   arg2 = (Dali::WidgetApplication *)jarg2;
57304   if (!arg2) {
57305     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
57306     return 0;
57307   }
57308   {
57309     try {
57310       result = (Dali::WidgetApplication *) &(arg1)->operator =((Dali::WidgetApplication const &)*arg2);
57311     } CALL_CATCH_EXCEPTION(0);
57312   }
57313   jresult = (void *)result;
57314   return jresult;
57315 }
57316
57317
57318 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WidgetApplication(void * jarg1) {
57319   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
57320
57321   arg1 = (Dali::WidgetApplication *)jarg1;
57322   {
57323     try {
57324       delete arg1;
57325       if( argWidgetV )
57326       {
57327         // free string data
57328         for( int i=0; i < argWidgetC+1; i++)
57329         {
57330           delete [] argWidgetV[i];
57331         }
57332         delete [] argWidgetV;
57333       }
57334     } CALL_CATCH_EXCEPTION();
57335   }
57336 }
57337
57338
57339 typedef Dali::Widget*(SWIGSTDCALL *CSharpCreateWidgetFunction)(const std::string&);
57340 CSharpCreateWidgetFunction _CSharpCreateWidgetFunction = NULL;
57341
57342 static Dali::Widget SWIGSTDCALL WidgetFactoryFunction( const std::string& widgetName )
57343 {
57344   Widget* widget = _CSharpCreateWidgetFunction( widgetName.c_str() );
57345   return *widget;
57346 }
57347
57348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetApplication_RegisterWidgetCreatingFunction(void * jarg1, char** jarg2, void * jarg3) {
57349   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
57350   std::string *arg2 = 0 ;
57351
57352   arg1 = (Dali::WidgetApplication *)jarg1;
57353   if (!jarg2) {
57354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57355     return ;
57356   }
57357   std::string arg2_str(*jarg2);
57358   arg2 = &arg2_str;
57359
57360   if(!_CSharpCreateWidgetFunction)
57361   {
57362     _CSharpCreateWidgetFunction = (Dali::Widget*(*)(const std::string&))jarg3;
57363   }
57364
57365   {
57366     try {
57367       (arg1)->RegisterWidgetCreatingFunction((std::string const &)*arg2, WidgetFactoryFunction);
57368     } CALL_CATCH_EXCEPTION();
57369   }
57370   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
57371 }
57372
57373
57374 //for PixelBuffer and ImageLoading
57375
57376 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelBuffer_SWIGUpcast(Dali::Devel::PixelBuffer *jarg1) {
57377     return (Dali::BaseHandle *)jarg1;
57378 }
57379
57380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_New(unsigned int jarg1, unsigned int jarg2, int jarg3) {
57381   void * jresult ;
57382   unsigned int arg1 ;
57383   unsigned int arg2 ;
57384   Dali::Pixel::Format arg3 ;
57385   Dali::Devel::PixelBuffer result;
57386
57387   arg1 = (unsigned int)jarg1;
57388   arg2 = (unsigned int)jarg2;
57389   arg3 = (Dali::Pixel::Format)jarg3;
57390   {
57391     try {
57392       result = Dali::Devel::PixelBuffer::New(arg1,arg2,arg3);
57393     } CALL_CATCH_EXCEPTION(0);
57394   }
57395   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
57396   return jresult;
57397 }
57398
57399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_0() {
57400   void * jresult ;
57401   Dali::Devel::PixelBuffer *result = 0 ;
57402
57403   {
57404     try {
57405       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer();
57406     } CALL_CATCH_EXCEPTION(0);
57407   }
57408   jresult = (void *)result;
57409   return jresult;
57410 }
57411
57412
57413 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelBuffer(void * jarg1) {
57414   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
57415
57416   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57417   {
57418     try {
57419       delete arg1;
57420     } CALL_CATCH_EXCEPTION();
57421   }
57422 }
57423
57424
57425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_1(void * jarg1) {
57426   void * jresult ;
57427   Dali::Devel::PixelBuffer *arg1 = 0 ;
57428   Dali::Devel::PixelBuffer *result = 0 ;
57429
57430   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57431   if (!arg1) {
57432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
57433     return 0;
57434   }
57435   {
57436     try {
57437       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer((Dali::Devel::PixelBuffer const &)*arg1);
57438     } CALL_CATCH_EXCEPTION(0);
57439   }
57440   jresult = (void *)result;
57441   return jresult;
57442 }
57443
57444
57445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Assign(void * jarg1, void * jarg2) {
57446   void * jresult ;
57447   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
57448   Dali::Devel::PixelBuffer *arg2 = 0 ;
57449   Dali::Devel::PixelBuffer *result = 0 ;
57450
57451   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57452   arg2 = (Dali::Devel::PixelBuffer *)jarg2;
57453   if (!arg2) {
57454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
57455     return 0;
57456   }
57457   {
57458     try {
57459       result = (Dali::Devel::PixelBuffer *) &(arg1)->operator =((Dali::Devel::PixelBuffer const &)*arg2);
57460     } CALL_CATCH_EXCEPTION(0);
57461   }
57462   jresult = (void *)result;
57463   return jresult;
57464 }
57465
57466
57467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Convert(void * jarg1) {
57468   void * jresult ;
57469   Dali::Devel::PixelBuffer *arg1 = 0 ;
57470   Dali::PixelData result;
57471
57472   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57473   if (!arg1) {
57474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer & type is null", 0);
57475     return 0;
57476   }
57477   {
57478     try {
57479       result = Dali::Devel::PixelBuffer::Convert(*arg1);
57480     } CALL_CATCH_EXCEPTION(0);
57481   }
57482   jresult = new Dali::PixelData((const Dali::PixelData &)result);
57483   return jresult;
57484 }
57485
57486
57487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_CreatePixelData(void * jarg1) {
57488   void * jresult ;
57489   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
57490   Dali::PixelData result;
57491
57492   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57493   {
57494     try {
57495       result = ((Dali::Devel::PixelBuffer const *)arg1)->CreatePixelData();
57496     } CALL_CATCH_EXCEPTION(0);
57497   }
57498   jresult = new Dali::PixelData((const Dali::PixelData &)result);
57499   return jresult;
57500 }
57501
57502
57503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_GetBuffer(void * jarg1) {
57504   void * jresult ;
57505   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
57506   unsigned char *result = 0 ;
57507
57508   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57509   {
57510     try {
57511       result = (unsigned char *)(arg1)->GetBuffer();
57512     } CALL_CATCH_EXCEPTION(0);
57513   }
57514    jresult = (void *)result;
57515    return jresult;
57516 }
57517
57518 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetWidth(void * jarg1) {
57519   unsigned int jresult ;
57520   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
57521   unsigned int result;
57522
57523   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57524   {
57525     try {
57526       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetWidth();
57527     } CALL_CATCH_EXCEPTION(0);
57528   }
57529   jresult = result;
57530   return jresult;
57531 }
57532
57533
57534 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetHeight(void * jarg1) {
57535   unsigned int jresult ;
57536   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
57537   unsigned int result;
57538
57539   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57540   {
57541     try {
57542       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetHeight();
57543     } CALL_CATCH_EXCEPTION(0);
57544   }
57545   jresult = result;
57546   return jresult;
57547 }
57548
57549
57550 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetPixelFormat(void * jarg1) {
57551   int jresult ;
57552   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
57553   Dali::Pixel::Format result;
57554
57555   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57556   {
57557     try {
57558       result = (Dali::Pixel::Format)((Dali::Devel::PixelBuffer const *)arg1)->GetPixelFormat();
57559     } CALL_CATCH_EXCEPTION(0);
57560   }
57561   jresult = (int)result;
57562   return jresult;
57563 }
57564
57565
57566 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_0(void * jarg1, void * jarg2, float jarg3, unsigned int jarg4) {
57567   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
57568   Dali::Devel::PixelBuffer arg2 ;
57569   float arg3 ;
57570   bool arg4 ;
57571   Dali::Devel::PixelBuffer *argp2 ;
57572
57573   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57574   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
57575   if (!argp2) {
57576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
57577     return ;
57578   }
57579   arg2 = *argp2;
57580   arg3 = (float)jarg3;
57581   arg4 = jarg4 ? true : false;
57582   {
57583     try {
57584       (arg1)->ApplyMask(arg2,arg3,arg4);
57585     } CALL_CATCH_EXCEPTION();
57586   }
57587 }
57588
57589
57590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
57591   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
57592   Dali::Devel::PixelBuffer arg2 ;
57593   float arg3 ;
57594   Dali::Devel::PixelBuffer *argp2 ;
57595
57596   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57597   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
57598   if (!argp2) {
57599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
57600     return ;
57601   }
57602   arg2 = *argp2;
57603   arg3 = (float)jarg3;
57604   {
57605     try {
57606       (arg1)->ApplyMask(arg2,arg3);
57607     } CALL_CATCH_EXCEPTION();
57608   }
57609 }
57610
57611
57612 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_2(void * jarg1, void * jarg2) {
57613   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
57614   Dali::Devel::PixelBuffer arg2 ;
57615   Dali::Devel::PixelBuffer *argp2 ;
57616
57617   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57618   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
57619   if (!argp2) {
57620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
57621     return ;
57622   }
57623   arg2 = *argp2;
57624   {
57625     try {
57626       (arg1)->ApplyMask(arg2);
57627     } CALL_CATCH_EXCEPTION();
57628   }
57629 }
57630
57631 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyGaussianBlur(void * jarg1, float jarg2) {
57632   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
57633   float arg2 ;
57634
57635   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57636   arg2 = (float)jarg2;
57637   {
57638     try {
57639       (arg1)->ApplyGaussianBlur(arg2);
57640     } CALL_CATCH_EXCEPTION();
57641   }
57642 }
57643
57644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Crop(void * jarg1, unsigned short jarg2, unsigned short jarg3, unsigned short jarg4, unsigned short jarg5) {
57645   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
57646   uint16_t arg2 ;
57647   uint16_t arg3 ;
57648   uint16_t arg4 ;
57649   uint16_t arg5 ;
57650
57651   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57652   arg2 = (uint16_t)jarg2;
57653   arg3 = (uint16_t)jarg3;
57654   arg4 = (uint16_t)jarg4;
57655   arg5 = (uint16_t)jarg5;
57656   {
57657     try {
57658       (arg1)->Crop(arg2,arg3,arg4,arg5);
57659     } CALL_CATCH_EXCEPTION();
57660   }
57661 }
57662
57663
57664 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Resize(void * jarg1, unsigned short jarg2, unsigned short jarg3) {
57665   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
57666   uint16_t arg2 ;
57667   uint16_t arg3 ;
57668
57669   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57670   arg2 = (uint16_t)jarg2;
57671   arg3 = (uint16_t)jarg3;
57672   {
57673     try {
57674       (arg1)->Resize(arg2,arg3);
57675     } CALL_CATCH_EXCEPTION();
57676   }
57677 }
57678
57679 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PixelBuffer_Rotate(void * jarg1, void* jarg2) {
57680   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
57681   Dali::Degree * arg2 ;
57682
57683   bool result = false;
57684
57685   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57686   arg2 = (Dali::Degree *)jarg2;
57687   {
57688     try {
57689       result = (arg1)->Rotate(*arg2);
57690     } CALL_CATCH_EXCEPTION(false);
57691   }
57692   return result;
57693 }
57694
57695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
57696   void * jresult ;
57697   std::string *arg1 = 0 ;
57698   Dali::ImageDimensions arg2 ;
57699   Dali::FittingMode::Type arg3 ;
57700   Dali::SamplingMode::Type arg4 ;
57701   bool arg5 ;
57702   Dali::ImageDimensions *argp2 ;
57703   Dali::Devel::PixelBuffer result;
57704
57705   if (!jarg1) {
57706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57707     return 0;
57708   }
57709   std::string arg1_str(jarg1);
57710   arg1 = &arg1_str;
57711   argp2 = (Dali::ImageDimensions *)jarg2;
57712   if (!argp2) {
57713     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
57714     return 0;
57715   }
57716   arg2 = *argp2;
57717   arg3 = (Dali::FittingMode::Type)jarg3;
57718   arg4 = (Dali::SamplingMode::Type)jarg4;
57719   arg5 = jarg5 ? true : false;
57720   {
57721     try {
57722       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4,arg5);
57723     } CALL_CATCH_EXCEPTION(0);
57724   }
57725   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
57726   return jresult;
57727 }
57728
57729
57730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
57731   void * jresult ;
57732   std::string *arg1 = 0 ;
57733   Dali::ImageDimensions arg2 ;
57734   Dali::FittingMode::Type arg3 ;
57735   Dali::SamplingMode::Type arg4 ;
57736   Dali::ImageDimensions *argp2 ;
57737   Dali::Devel::PixelBuffer result;
57738
57739   if (!jarg1) {
57740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57741     return 0;
57742   }
57743   std::string arg1_str(jarg1);
57744   arg1 = &arg1_str;
57745   argp2 = (Dali::ImageDimensions *)jarg2;
57746   if (!argp2) {
57747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
57748     return 0;
57749   }
57750   arg2 = *argp2;
57751   arg3 = (Dali::FittingMode::Type)jarg3;
57752   arg4 = (Dali::SamplingMode::Type)jarg4;
57753   {
57754     try {
57755       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4);
57756     } CALL_CATCH_EXCEPTION(0);
57757   }
57758   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
57759   return jresult;
57760 }
57761
57762
57763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
57764   void * jresult ;
57765   std::string *arg1 = 0 ;
57766   Dali::ImageDimensions arg2 ;
57767   Dali::FittingMode::Type arg3 ;
57768   Dali::ImageDimensions *argp2 ;
57769   Dali::Devel::PixelBuffer result;
57770
57771   if (!jarg1) {
57772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57773     return 0;
57774   }
57775   std::string arg1_str(jarg1);
57776   arg1 = &arg1_str;
57777   argp2 = (Dali::ImageDimensions *)jarg2;
57778   if (!argp2) {
57779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
57780     return 0;
57781   }
57782   arg2 = *argp2;
57783   arg3 = (Dali::FittingMode::Type)jarg3;
57784   {
57785     try {
57786       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3);
57787     } CALL_CATCH_EXCEPTION(0);
57788   }
57789   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
57790   return jresult;
57791 }
57792
57793
57794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_3(char * jarg1, void * jarg2) {
57795   void * jresult ;
57796   std::string *arg1 = 0 ;
57797   Dali::ImageDimensions arg2 ;
57798   Dali::ImageDimensions *argp2 ;
57799   Dali::Devel::PixelBuffer result;
57800
57801   if (!jarg1) {
57802     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57803     return 0;
57804   }
57805   std::string arg1_str(jarg1);
57806   arg1 = &arg1_str;
57807   argp2 = (Dali::ImageDimensions *)jarg2;
57808   if (!argp2) {
57809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
57810     return 0;
57811   }
57812   arg2 = *argp2;
57813   {
57814     try {
57815       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2);
57816     } CALL_CATCH_EXCEPTION(0);
57817   }
57818   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
57819   return jresult;
57820 }
57821
57822
57823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_4(char * jarg1) {
57824   void * jresult ;
57825   std::string *arg1 = 0 ;
57826   Dali::Devel::PixelBuffer result;
57827
57828   if (!jarg1) {
57829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57830     return 0;
57831   }
57832   std::string arg1_str(jarg1);
57833   arg1 = &arg1_str;
57834   {
57835     try {
57836       result = Dali::LoadImageFromFile((std::string const &)*arg1);
57837     } CALL_CATCH_EXCEPTION(0);
57838   }
57839   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
57840   return jresult;
57841 }
57842
57843
57844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
57845   void * jresult ;
57846   std::string *arg1 = 0 ;
57847   Dali::ImageDimensions arg2 ;
57848   Dali::FittingMode::Type arg3 ;
57849   Dali::SamplingMode::Type arg4 ;
57850   bool arg5 ;
57851   Dali::ImageDimensions *argp2 ;
57852   Dali::ImageDimensions result;
57853
57854   if (!jarg1) {
57855     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57856     return 0;
57857   }
57858   std::string arg1_str(jarg1);
57859   arg1 = &arg1_str;
57860   argp2 = (Dali::ImageDimensions *)jarg2;
57861   if (!argp2) {
57862     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
57863     return 0;
57864   }
57865   arg2 = *argp2;
57866   arg3 = (Dali::FittingMode::Type)jarg3;
57867   arg4 = (Dali::SamplingMode::Type)jarg4;
57868   arg5 = jarg5 ? true : false;
57869   {
57870     try {
57871       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4,arg5);
57872     } CALL_CATCH_EXCEPTION(0);
57873   }
57874   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
57875   return jresult;
57876 }
57877
57878
57879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
57880   void * jresult ;
57881   std::string *arg1 = 0 ;
57882   Dali::ImageDimensions arg2 ;
57883   Dali::FittingMode::Type arg3 ;
57884   Dali::SamplingMode::Type arg4 ;
57885   Dali::ImageDimensions *argp2 ;
57886   Dali::ImageDimensions result;
57887
57888   if (!jarg1) {
57889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57890     return 0;
57891   }
57892   std::string arg1_str(jarg1);
57893   arg1 = &arg1_str;
57894   argp2 = (Dali::ImageDimensions *)jarg2;
57895   if (!argp2) {
57896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
57897     return 0;
57898   }
57899   arg2 = *argp2;
57900   arg3 = (Dali::FittingMode::Type)jarg3;
57901   arg4 = (Dali::SamplingMode::Type)jarg4;
57902   {
57903     try {
57904       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4);
57905     } CALL_CATCH_EXCEPTION(0);
57906   }
57907   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
57908   return jresult;
57909 }
57910
57911
57912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
57913   void * jresult ;
57914   std::string *arg1 = 0 ;
57915   Dali::ImageDimensions arg2 ;
57916   Dali::FittingMode::Type arg3 ;
57917   Dali::ImageDimensions *argp2 ;
57918   Dali::ImageDimensions result;
57919
57920   if (!jarg1) {
57921     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57922     return 0;
57923   }
57924   std::string arg1_str(jarg1);
57925   arg1 = &arg1_str;
57926   argp2 = (Dali::ImageDimensions *)jarg2;
57927   if (!argp2) {
57928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
57929     return 0;
57930   }
57931   arg2 = *argp2;
57932   arg3 = (Dali::FittingMode::Type)jarg3;
57933   {
57934     try {
57935       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3);
57936     } CALL_CATCH_EXCEPTION(0);
57937   }
57938   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
57939   return jresult;
57940 }
57941
57942
57943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_3(char * jarg1, void * jarg2) {
57944   void * jresult ;
57945   std::string *arg1 = 0 ;
57946   Dali::ImageDimensions arg2 ;
57947   Dali::ImageDimensions *argp2 ;
57948   Dali::ImageDimensions result;
57949
57950   if (!jarg1) {
57951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57952     return 0;
57953   }
57954   std::string arg1_str(jarg1);
57955   arg1 = &arg1_str;
57956   argp2 = (Dali::ImageDimensions *)jarg2;
57957   if (!argp2) {
57958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
57959     return 0;
57960   }
57961   arg2 = *argp2;
57962   {
57963     try {
57964       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2);
57965     } CALL_CATCH_EXCEPTION(0);
57966   }
57967   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
57968   return jresult;
57969 }
57970
57971
57972 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_4(char * jarg1) {
57973   void * jresult ;
57974   std::string *arg1 = 0 ;
57975   Dali::ImageDimensions result;
57976
57977   if (!jarg1) {
57978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57979     return 0;
57980   }
57981   std::string arg1_str(jarg1);
57982   arg1 = &arg1_str;
57983   {
57984     try {
57985       result = Dali::GetClosestImageSize((std::string const &)*arg1);
57986     } CALL_CATCH_EXCEPTION(0);
57987   }
57988   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
57989   return jresult;
57990 }
57991
57992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetOriginalImageSize(char * jarg1) {
57993   void * jresult ;
57994   std::string *arg1 = 0 ;
57995   Dali::ImageDimensions result;
57996
57997   if (!jarg1) {
57998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57999     return 0;
58000   }
58001   std::string arg1_str(jarg1);
58002   arg1 = &arg1_str;
58003   {
58004     try {
58005       result = Dali::GetOriginalImageSize((std::string const &)*arg1);
58006     } CALL_CATCH_EXCEPTION(0);
58007   }
58008   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
58009   return jresult;
58010 }
58011
58012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
58013   void * jresult ;
58014   std::string *arg1 = 0 ;
58015   Dali::ImageDimensions arg2 ;
58016   Dali::FittingMode::Type arg3 ;
58017   Dali::SamplingMode::Type arg4 ;
58018   bool arg5 ;
58019   Dali::ImageDimensions *argp2 ;
58020   Dali::Devel::PixelBuffer result;
58021
58022   if (!jarg1) {
58023     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58024     return 0;
58025   }
58026   std::string arg1_str(jarg1);
58027   arg1 = &arg1_str;
58028   argp2 = (Dali::ImageDimensions *)jarg2;
58029   if (!argp2) {
58030     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
58031     return 0;
58032   }
58033   arg2 = *argp2;
58034   arg3 = (Dali::FittingMode::Type)jarg3;
58035   arg4 = (Dali::SamplingMode::Type)jarg4;
58036   arg5 = jarg5 ? true : false;
58037   {
58038     try {
58039       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4,arg5);
58040     } CALL_CATCH_EXCEPTION(0);
58041   }
58042   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
58043   return jresult;
58044 }
58045
58046
58047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
58048   void * jresult ;
58049   std::string *arg1 = 0 ;
58050   Dali::ImageDimensions arg2 ;
58051   Dali::FittingMode::Type arg3 ;
58052   Dali::SamplingMode::Type arg4 ;
58053   Dali::ImageDimensions *argp2 ;
58054   Dali::Devel::PixelBuffer result;
58055
58056   if (!jarg1) {
58057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58058     return 0;
58059   }
58060   std::string arg1_str(jarg1);
58061   arg1 = &arg1_str;
58062   argp2 = (Dali::ImageDimensions *)jarg2;
58063   if (!argp2) {
58064     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
58065     return 0;
58066   }
58067   arg2 = *argp2;
58068   arg3 = (Dali::FittingMode::Type)jarg3;
58069   arg4 = (Dali::SamplingMode::Type)jarg4;
58070   {
58071     try {
58072       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4);
58073     } CALL_CATCH_EXCEPTION(0);
58074   }
58075   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
58076   return jresult;
58077 }
58078
58079
58080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
58081   void * jresult ;
58082   std::string *arg1 = 0 ;
58083   Dali::ImageDimensions arg2 ;
58084   Dali::FittingMode::Type arg3 ;
58085   Dali::ImageDimensions *argp2 ;
58086   Dali::Devel::PixelBuffer result;
58087
58088   if (!jarg1) {
58089     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58090     return 0;
58091   }
58092   std::string arg1_str(jarg1);
58093   arg1 = &arg1_str;
58094   argp2 = (Dali::ImageDimensions *)jarg2;
58095   if (!argp2) {
58096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
58097     return 0;
58098   }
58099   arg2 = *argp2;
58100   arg3 = (Dali::FittingMode::Type)jarg3;
58101   {
58102     try {
58103       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3);
58104     } CALL_CATCH_EXCEPTION(0);
58105   }
58106   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
58107   return jresult;
58108 }
58109
58110
58111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_3(char * jarg1, void * jarg2) {
58112   void * jresult ;
58113   std::string *arg1 = 0 ;
58114   Dali::ImageDimensions arg2 ;
58115   Dali::ImageDimensions *argp2 ;
58116   Dali::Devel::PixelBuffer result;
58117
58118   if (!jarg1) {
58119     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58120     return 0;
58121   }
58122   std::string arg1_str(jarg1);
58123   arg1 = &arg1_str;
58124   argp2 = (Dali::ImageDimensions *)jarg2;
58125   if (!argp2) {
58126     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
58127     return 0;
58128   }
58129   arg2 = *argp2;
58130   {
58131     try {
58132       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2);
58133     } CALL_CATCH_EXCEPTION(0);
58134   }
58135   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
58136   return jresult;
58137 }
58138
58139
58140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_4(char * jarg1) {
58141   void * jresult ;
58142   std::string *arg1 = 0 ;
58143   Dali::Devel::PixelBuffer result;
58144
58145   if (!jarg1) {
58146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58147     return 0;
58148   }
58149   std::string arg1_str(jarg1);
58150   arg1 = &arg1_str;
58151   {
58152     try {
58153       result = Dali::DownloadImageSynchronously((std::string const &)*arg1);
58154     } CALL_CATCH_EXCEPTION(0);
58155   }
58156   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
58157   return jresult;
58158 }
58159
58160
58161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New() {
58162   void * jresult ;
58163   Dali::Toolkit::WebView result;
58164
58165   {
58166     try {
58167       result = Dali::Toolkit::WebView::New();
58168     } CALL_CATCH_EXCEPTION(0);
58169   }
58170   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
58171   return jresult;
58172 }
58173
58174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New_2(char * jarg1, char * jarg2) {
58175   void * jresult ;
58176   Dali::Toolkit::WebView result;
58177
58178   std::string *arg1;
58179   std::string *arg2;
58180
58181   if (!jarg1) {
58182     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg1 is null string", 0);
58183     return 0;
58184   }
58185   if (!jarg2) {
58186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg2 is null string", 0);
58187     return 0;
58188   }
58189
58190   std::string jarg1_str = std::string(jarg1);
58191   std::string jarg2_str = std::string(jarg2);
58192
58193   arg1 = &jarg1_str;
58194   arg2 = &jarg2_str;
58195
58196   {
58197     try {
58198       result = Dali::Toolkit::WebView::New( (std::string const &)*arg1, (std::string const &)*arg2);
58199     } CALL_CATCH_EXCEPTION(0);
58200   }
58201   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
58202   return jresult;
58203 }
58204
58205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebView__SWIG_1(void * jarg1) {
58206   void * jresult ;
58207   Dali::Toolkit::WebView *arg1 = 0 ;
58208   Dali::Toolkit::WebView *result = 0 ;
58209
58210   arg1 = (Dali::Toolkit::WebView *)jarg1;
58211   if (!arg1) {
58212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
58213     return 0;
58214   }
58215   {
58216     try {
58217       result = (Dali::Toolkit::WebView *)new Dali::Toolkit::WebView((Dali::Toolkit::WebView const &)*arg1);
58218     } CALL_CATCH_EXCEPTION(0);
58219   }
58220   jresult = (void *)result;
58221   return jresult;
58222 }
58223
58224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebView(void * jarg1) {
58225   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58226   arg1 = (Dali::Toolkit::WebView *)jarg1;
58227   {
58228     try {
58229       delete arg1;
58230     } CALL_CATCH_EXCEPTION();
58231   }
58232 }
58233
58234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_Assign(void * jarg1, void * jarg2) {
58235   void * jresult ;
58236   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58237   Dali::Toolkit::WebView *arg2 = 0 ;
58238   Dali::Toolkit::WebView *result = 0 ;
58239
58240   arg1 = (Dali::Toolkit::WebView *)jarg1;
58241   arg2 = (Dali::Toolkit::WebView *)jarg2;
58242   if (!arg2) {
58243     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
58244     return 0;
58245   }
58246   {
58247     try {
58248       result = (Dali::Toolkit::WebView *) &(arg1)->operator =((Dali::Toolkit::WebView const &)*arg2);
58249     } CALL_CATCH_EXCEPTION(0);
58250   }
58251   jresult = (void *)result;
58252   return jresult;
58253 }
58254
58255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_DownCast(void * jarg1) {
58256   void * jresult ;
58257   Dali::BaseHandle arg1 ;
58258   Dali::BaseHandle *argp1 ;
58259   Dali::Toolkit::WebView result;
58260
58261   argp1 = (Dali::BaseHandle *)jarg1;
58262   if (!argp1) {
58263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
58264     return 0;
58265   }
58266   arg1 = *argp1;
58267   {
58268     try {
58269       result = Dali::Toolkit::WebView::DownCast(arg1);
58270     } CALL_CATCH_EXCEPTION(0);
58271   }
58272   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
58273   return jresult;
58274 }
58275
58276 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_URL_get() {
58277   return (int) Dali::Toolkit::WebView::Property::URL;
58278 }
58279
58280 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_CACHE_MODEL_get() {
58281   return (int) Dali::Toolkit::WebView::Property::CACHE_MODEL;
58282 }
58283
58284 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_COOKIE_ACCEPT_POLICY_get() {
58285   return (int) Dali::Toolkit::WebView::Property::COOKIE_ACCEPT_POLICY;
58286 }
58287
58288 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_USER_AGENT_get() {
58289   return (int) Dali::Toolkit::WebView::Property::USER_AGENT;
58290 }
58291
58292 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_ENABLE_JAVASCRIPT_get() {
58293   return (int) Dali::Toolkit::WebView::Property::ENABLE_JAVASCRIPT;
58294 }
58295
58296 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_LOAD_IMAGES_AUTOMATICALLY_get() {
58297   return (int) Dali::Toolkit::WebView::Property::LOAD_IMAGES_AUTOMATICALLY;
58298 }
58299
58300 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_DEFAULT_TEXT_ENCODING_NAME_get() {
58301   return (int) Dali::Toolkit::WebView::Property::DEFAULT_TEXT_ENCODING_NAME;
58302 }
58303
58304 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_DEFAULT_FONT_SIZE_get() {
58305   return (int) Dali::Toolkit::WebView::Property::DEFAULT_FONT_SIZE;
58306 }
58307
58308 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadUrl(void * jarg1, char * jarg2) {
58309   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58310   std::string *arg2;
58311
58312   arg1 = (Dali::Toolkit::WebView *)jarg1;
58313
58314   if (!jarg2) {
58315     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58316     return;
58317   }
58318
58319   std::string jarg2str = std::string(jarg2);
58320   arg2 = &jarg2str;
58321   {
58322     try {
58323       (arg1)->LoadUrl((std::string const &)*arg2);
58324     } CALL_CATCH_EXCEPTION();
58325   }
58326 }
58327
58328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadHTMLString(void * jarg1, char * jarg2) {
58329   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58330   std::string *arg2;
58331
58332   arg1 = (Dali::Toolkit::WebView *)jarg1;
58333   if (!jarg2) {
58334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58335     return;
58336   }
58337   std::string jarg2str = std::string(jarg2);
58338   arg2 = &jarg2str;
58339   {
58340     try {
58341       (arg1)->LoadHTMLString((std::string const &)*arg2);
58342     } CALL_CATCH_EXCEPTION();
58343   }
58344 }
58345
58346 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Reload(void * jarg1) {
58347   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58348
58349   arg1 = (Dali::Toolkit::WebView *)jarg1;
58350   {
58351     try {
58352       (arg1)->Reload();
58353     } CALL_CATCH_EXCEPTION();
58354   }
58355 }
58356
58357 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_StopLoading(void * jarg1) {
58358   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58359
58360   arg1 = (Dali::Toolkit::WebView *)jarg1;
58361   {
58362     try {
58363       (arg1)->StopLoading();
58364     } CALL_CATCH_EXCEPTION();
58365   }
58366 }
58367
58368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Suspend(void * jarg1) {
58369   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58370
58371   arg1 = (Dali::Toolkit::WebView *)jarg1;
58372   {
58373     try {
58374       (arg1)->Suspend();
58375     } CALL_CATCH_EXCEPTION();
58376   }
58377 }
58378
58379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Resume(void * jarg1) {
58380   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58381
58382   arg1 = (Dali::Toolkit::WebView *)jarg1;
58383   {
58384     try {
58385       (arg1)->Resume();
58386     } CALL_CATCH_EXCEPTION();
58387   }
58388 }
58389
58390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoBack(void * jarg1) {
58391   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58392
58393   arg1 = (Dali::Toolkit::WebView *)jarg1;
58394   {
58395     try {
58396       (arg1)->GoBack();
58397     } CALL_CATCH_EXCEPTION();
58398   }
58399 }
58400
58401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoForward(void * jarg1) {
58402   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58403
58404   arg1 = (Dali::Toolkit::WebView *)jarg1;
58405   {
58406     try {
58407       (arg1)->GoForward();
58408     } CALL_CATCH_EXCEPTION();
58409   }
58410 }
58411
58412 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoBack(void * jarg1) {
58413   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58414   bool ret;
58415
58416   arg1 = (Dali::Toolkit::WebView *)jarg1;
58417   {
58418     try {
58419       ret = (arg1)->CanGoBack();
58420     } CALL_CATCH_EXCEPTION(0);
58421   }
58422   return ret;
58423 }
58424
58425 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoForward(void * jarg1) {
58426   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58427   bool ret;
58428
58429   arg1 = (Dali::Toolkit::WebView *)jarg1;
58430   {
58431     try {
58432       ret = (arg1)->CanGoForward();
58433     } CALL_CATCH_EXCEPTION(0);
58434   }
58435   return ret;
58436 }
58437
58438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_EvaluateJavaScript(void * jarg1, char * jarg2, void* jarg3) {
58439   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58440   std::string *arg2;
58441
58442   arg1 = (Dali::Toolkit::WebView *)jarg1;
58443   if (!jarg2) {
58444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58445     return;
58446   }
58447   std::string jarg2_str = std::string(jarg2);
58448   arg2 = &jarg2_str;
58449
58450   {
58451     try {
58452       if (jarg3) {
58453         void (*handler)(char*) = (void (*)(char*)) jarg3;
58454         (arg1)->EvaluateJavaScript((std::string const &)*arg2, [handler](const std::string& result) {
58455           handler(SWIG_csharp_string_callback(result.c_str()));
58456         });
58457       } else {
58458         (arg1)->EvaluateJavaScript((std::string const &)*arg2);
58459       }
58460     } CALL_CATCH_EXCEPTION();
58461   }
58462 }
58463
58464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_AddJavaScriptMessageHandler(void* jarg1, char* jarg2, void* jarg3)
58465 {
58466   if (!jarg2) {
58467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58468     return;
58469   }
58470
58471   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
58472   std::string exposedObjectName = jarg2;
58473   void (*handler)(char*) = (void (*)(char*)) jarg3;
58474
58475   {
58476     try {
58477       webview->AddJavaScriptMessageHandler(exposedObjectName, [handler](const std::string& message) {
58478         handler(SWIG_csharp_string_callback(message.c_str()));
58479       });
58480     } CALL_CATCH_EXCEPTION();
58481   }
58482 }
58483
58484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearHistory(void * jarg1) {
58485   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58486
58487   arg1 = (Dali::Toolkit::WebView *)jarg1;
58488   {
58489     try {
58490       (arg1)->ClearHistory();
58491     } CALL_CATCH_EXCEPTION();
58492   }
58493 }
58494
58495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearCache(void * jarg1) {
58496   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58497
58498   arg1 = (Dali::Toolkit::WebView *)jarg1;
58499   {
58500     try {
58501       (arg1)->ClearCache();
58502     } CALL_CATCH_EXCEPTION();
58503   }
58504 }
58505
58506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearCookies(void * jarg1) {
58507   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58508
58509   arg1 = (Dali::Toolkit::WebView *)jarg1;
58510   {
58511     try {
58512       (arg1)->ClearCookies();
58513     } CALL_CATCH_EXCEPTION();
58514   }
58515 }
58516
58517 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_WebView_SWIGUpcast(Dali::Toolkit::WebView *jarg1) {
58518     return (Dali::Toolkit::Control *)jarg1;
58519 }
58520
58521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadSignal_PageLoadStarted(void * jarg1) {
58522   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
58523   SignalConverter::WebViewPageLoadSignal* result = NULL;
58524   {
58525     try {
58526       result = new SignalConverter::WebViewPageLoadSignal(&webview->PageLoadStartedSignal());
58527     } CALL_CATCH_EXCEPTION(0);
58528   }
58529   return (void*) result;
58530 }
58531
58532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadSignal_PageLoadFinished(void * jarg1) {
58533   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
58534   SignalConverter::WebViewPageLoadSignal* result = NULL;
58535   {
58536     try {
58537       result = new SignalConverter::WebViewPageLoadSignal(&webview->PageLoadFinishedSignal());
58538     } CALL_CATCH_EXCEPTION(0);
58539   }
58540   return (void*) result;
58541 }
58542
58543 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewPageLoadSignal(void * jarg1)
58544 {
58545   SignalConverter::WebViewPageLoadSignal* object = (SignalConverter::WebViewPageLoadSignal*) jarg1;
58546   {
58547     try {
58548       delete object;
58549     } CALL_CATCH_EXCEPTION();
58550   }
58551 }
58552
58553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadSignal_Connect(void * jarg1, void * jarg2)
58554 {
58555   SignalConverter::WebViewPageLoadSignal* proxy = (SignalConverter::WebViewPageLoadSignal*) jarg1;
58556   SignalConverter::WebViewPageLoadSignal::CallbackType callback = (SignalConverter::WebViewPageLoadSignal::CallbackType) jarg2;
58557   {
58558     try {
58559       proxy->Connect(callback);
58560     } CALL_CATCH_EXCEPTION();
58561   }
58562 }
58563
58564
58565 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadSignal_Disconnect(void * jarg1, void * jarg2) {
58566   SignalConverter::WebViewPageLoadSignal* proxy = (SignalConverter::WebViewPageLoadSignal*) jarg1;
58567   SignalConverter::WebViewPageLoadSignal::CallbackType callback = (SignalConverter::WebViewPageLoadSignal::CallbackType) jarg2;
58568   {
58569     try {
58570       proxy->Disconnect(callback);
58571     } CALL_CATCH_EXCEPTION();
58572   }
58573 }
58574
58575 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadErrorSignal_PageLoadError(void * jarg1) {
58576   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
58577   SignalConverter::WebViewPageLoadErrorSignal* result = NULL;
58578   {
58579     try {
58580       result = new SignalConverter::WebViewPageLoadErrorSignal(&webview->PageLoadErrorSignal());
58581     } CALL_CATCH_EXCEPTION(0);
58582   }
58583   return (void*) result;
58584 }
58585
58586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewPageLoadErrorSignal(void * jarg1)
58587 {
58588   SignalConverter::WebViewPageLoadErrorSignal* object = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
58589   {
58590     try {
58591       delete object;
58592     } CALL_CATCH_EXCEPTION();
58593   }
58594 }
58595
58596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadErrorSignal_Connect(void * jarg1, void * jarg2)
58597 {
58598   SignalConverter::WebViewPageLoadErrorSignal* proxy = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
58599   SignalConverter::WebViewPageLoadErrorSignal::CallbackType callback = (SignalConverter::WebViewPageLoadErrorSignal::CallbackType) jarg2;
58600   {
58601     try {
58602       proxy->Connect(callback);
58603     } CALL_CATCH_EXCEPTION();
58604   }
58605 }
58606
58607
58608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadErrorSignal_Disconnect(void * jarg1, void * jarg2) {
58609   SignalConverter::WebViewPageLoadErrorSignal* proxy = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
58610   SignalConverter::WebViewPageLoadErrorSignal::CallbackType callback = (SignalConverter::WebViewPageLoadErrorSignal::CallbackType) jarg2;
58611   {
58612     try {
58613       proxy->Disconnect(callback);
58614     } CALL_CATCH_EXCEPTION();
58615   }
58616 }
58617
58618 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetEnvironmentVariable(char * jarg1) {
58619   const char * result = EnvironmentVariable::GetEnvironmentVariable(jarg1);
58620   char * jresult = SWIG_csharp_string_callback((const char *)result);
58621   return jresult;
58622 }
58623
58624 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_SetEnvironmentVariable(char * jarg1, char * jarg2) {
58625   bool result = EnvironmentVariable::SetEnvironmentVariable(jarg1, jarg2);
58626   return result;
58627 }
58628
58629
58630 struct NativeImageSourcePtrHandle
58631 {
58632   NativeImageSourcePtr Ptr;
58633 };
58634
58635 SWIGEXPORT NativeImageInterface* SWIGSTDCALL CSharp_Dali_NativeImageSource_Upcast(void* jarg1)
58636 {
58637   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
58638   return (NativeImageInterface*)(arg1);
58639 }
58640
58641 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_New_Handle(unsigned int jarg1, unsigned int jarg2, int jarg3)
58642 {
58643   void* jresult;
58644   NativeImageSourcePtrHandle* handle = new NativeImageSourcePtrHandle();
58645   {
58646     try {
58647       handle->Ptr = ( NativeImageSource::New(jarg1, jarg2, (NativeImageSource::ColorDepth)jarg3) );
58648     }
58649     catch (std::out_of_range & e) {
58650       {
58651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58652       };
58653     }
58654     catch (std::exception & e) {
58655       {
58656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58657       };
58658     }
58659     catch (Dali::DaliException e) {
58660       {
58661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58662       };
58663     }
58664     catch (...) {
58665       {
58666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58667       };
58668     }
58669   }
58670   jresult = (void *)handle;
58671   return jresult;
58672 }
58673
58674 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_New(void* jarg1)
58675 {
58676   void* jresult;
58677   NativeImageSourcePtrHandle* handle = (NativeImageSourcePtrHandle*)jarg1;
58678   jresult = (void*)( handle->Ptr.Get() );
58679   return jresult;
58680 }
58681
58682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageSource_Delete(void* jarg1) {
58683   NativeImageSourcePtrHandle* arg1 = (NativeImageSourcePtrHandle*)jarg1;
58684   {
58685     try {
58686       delete arg1;
58687     }
58688     catch (std::out_of_range & e) {
58689       {
58690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
58691       };
58692     }
58693     catch (std::exception & e) {
58694       {
58695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
58696       };
58697     }
58698     catch (Dali::DaliException e) {
58699       {
58700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return;
58701       };
58702     }
58703     catch (...) {
58704       {
58705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return;
58706       };
58707     }
58708   }
58709 }
58710
58711 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_AcquireBuffer(void* jarg1, int* jarg2, int* jarg3, int* jarg4)
58712 {
58713   void* jresult;
58714   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
58715   uint16_t* arg2 = (uint16_t*)(jarg2);
58716   uint16_t* arg3 = (uint16_t*)(jarg3);
58717   uint16_t* arg4 = (uint16_t*)(jarg4);
58718   {
58719     try {
58720       jresult = (void *)Dali::DevelNativeImageSource::AcquireBuffer( *arg1, *arg2, *arg3, *arg4 );
58721     }
58722     catch (std::out_of_range & e) {
58723       {
58724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58725       };
58726     }
58727     catch (std::exception & e) {
58728       {
58729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58730       };
58731     }
58732     catch (Dali::DaliException e) {
58733       {
58734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58735       };
58736     }
58737     catch (...) {
58738       {
58739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58740       };
58741     }
58742   }
58743   return jresult;
58744 }
58745
58746 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NativeImageSource_ReleaseBuffer(void* jarg1)
58747 {
58748   bool jresult;
58749   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
58750
58751   {
58752     try {
58753       jresult = Dali::DevelNativeImageSource::ReleaseBuffer( *arg1 );
58754     }
58755     catch (std::out_of_range & e) {
58756       {
58757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58758       };
58759     }
58760     catch (std::exception & e) {
58761       {
58762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58763       };
58764     }
58765     catch (Dali::DaliException e) {
58766       {
58767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58768       };
58769     }
58770     catch (...) {
58771       {
58772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58773       };
58774     }
58775   }
58776   return jresult;
58777 }
58778
58779
58780 #ifdef __cplusplus
58781 }
58782 #endif