dali-csharp-binder/src/dali_wrap.cpp

   1 /* ----------------------------------------------------------------------------
   2  * This file was automatically generated by SWIG (http://www.swig.org).
   3  * Version 3.0.9
   4  *
   5  * This file is not intended to be easily readable and contains a number of
   6  * coding conventions designed to improve portability and efficiency. Do not make
   7  * changes to this file unless you know what you are doing--modify the SWIG
   8  * interface file instead.
   9  * ----------------------------------------------------------------------------- */
  10
  11 #ifndef SWIGCSHARP
  12 #define SWIGCSHARP
  13 #endif
  14
  15 #define SWIG_DIRECTORS
  16
  17 #ifdef __cplusplus
  18 /* SwigValueWrapper is described in swig.swg */
  19 template<typename T> class SwigValueWrapper {
  20   struct SwigMovePointer {
  21     T *ptr;
  22     SwigMovePointer(T *p) : ptr(p) { }
  23     ~SwigMovePointer() { delete ptr; }
  24     SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
  25   } pointer;
  26   SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
  27   SwigValueWrapper(const SwigValueWrapper<T>& rhs);
  28 public:
  29   SwigValueWrapper() : pointer(0) { }
  30   SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
  31   operator T&() const { return *pointer.ptr; }
  32   T *operator&() { return pointer.ptr; }
  33 };
  34
  35 template <typename T> T SwigValueInit() {
  36   return T();
  37 }
  38 #endif
  39
  40 /* -----------------------------------------------------------------------------
  41  *  This section contains generic SWIG labels for method/variable
  42  *  declarations/attributes, and other compiler dependent labels.
  43  * ----------------------------------------------------------------------------- */
  44
  45 /* template workaround for compilers that cannot correctly implement the C++ standard */
  46 #ifndef SWIGTEMPLATEDISAMBIGUATOR
  47 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
  48 #  define SWIGTEMPLATEDISAMBIGUATOR template
  49 # elif defined(__HP_aCC)
  50 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
  51 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
  52 #  define SWIGTEMPLATEDISAMBIGUATOR template
  53 # else
  54 #  define SWIGTEMPLATEDISAMBIGUATOR
  55 # endif
  56 #endif
  57
  58 /* inline attribute */
  59 #ifndef SWIGINLINE
  60 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
  61 #   define SWIGINLINE inline
  62 # else
  63 #   define SWIGINLINE
  64 # endif
  65 #endif
  66
  67 /* attribute recognised by some compilers to avoid 'unused' warnings */
  68 #ifndef SWIGUNUSED
  69 # if defined(__GNUC__)
  70 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
  71 #     define SWIGUNUSED __attribute__ ((__unused__))
  72 #   else
  73 #     define SWIGUNUSED
  74 #   endif
  75 # elif defined(__ICC)
  76 #   define SWIGUNUSED __attribute__ ((__unused__))
  77 # else
  78 #   define SWIGUNUSED
  79 # endif
  80 #endif
  81
  82 #ifndef SWIG_MSC_UNSUPPRESS_4505
  83 # if defined(_MSC_VER)
  84 #   pragma warning(disable : 4505) /* unreferenced local function has been removed */
  85 # endif
  86 #endif
  87
  88 #ifndef SWIGUNUSEDPARM
  89 # ifdef __cplusplus
  90 #   define SWIGUNUSEDPARM(p)
  91 # else
  92 #   define SWIGUNUSEDPARM(p) p SWIGUNUSED
  93 # endif
  94 #endif
  95
  96 /* internal SWIG method */
  97 #ifndef SWIGINTERN
  98 # define SWIGINTERN static SWIGUNUSED
  99 #endif
 100
 101 /* internal inline SWIG method */
 102 #ifndef SWIGINTERNINLINE
 103 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
 104 #endif
 105
 106 /* exporting methods */
 107 #if defined(__GNUC__)
 108 #  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
 109 #    ifndef GCC_HASCLASSVISIBILITY
 110 #      define GCC_HASCLASSVISIBILITY
 111 #    endif
 112 #  endif
 113 #endif
 114
 115 #ifndef SWIGEXPORT
 116 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 117 #   if defined(STATIC_LINKED)
 118 #     define SWIGEXPORT
 119 #   else
 120 #     define SWIGEXPORT __declspec(dllexport)
 121 #   endif
 122 # else
 123 #   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
 124 #     define SWIGEXPORT __attribute__ ((visibility("default")))
 125 #   else
 126 #     define SWIGEXPORT
 127 #   endif
 128 # endif
 129 #endif
 130
 131 /* calling conventions for Windows */
 132 #ifndef SWIGSTDCALL
 133 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 134 #   define SWIGSTDCALL __stdcall
 135 # else
 136 #   define SWIGSTDCALL
 137 # endif
 138 #endif
 139
 140 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
 141 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
 142 # define _CRT_SECURE_NO_DEPRECATE
 143 #endif
 144
 145 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
 146 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
 147 # define _SCL_SECURE_NO_DEPRECATE
 148 #endif
 149
 150 /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
 151 #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
 152 # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
 153 #endif
 154
 155 /* Intel's compiler complains if a variable which was never initialised is
 156  * cast to void, which is a common idiom which we use to indicate that we
 157  * are aware a variable isn't used.  So we just silence that warning.
 158  * See: https://github.com/swig/swig/issues/192 for more discussion.
 159  */
 160 #ifdef __INTEL_COMPILER
 161 # pragma warning disable 592
 162 #endif
 163
 164
 165 #include <stdlib.h>
 166 #include <string.h>
 167 #include <stdio.h>
 168
 169 /* Support for throwing C# exceptions from C/C++. There are two types:
 170  * Exceptions that take a message and ArgumentExceptions that take a message and a parameter name. */
 171 typedef enum {
 172   SWIG_CSharpApplicationException,
 173   SWIG_CSharpArithmeticException,
 174   SWIG_CSharpDivideByZeroException,
 175   SWIG_CSharpIndexOutOfRangeException,
 176   SWIG_CSharpInvalidCastException,
 177   SWIG_CSharpInvalidOperationException,
 178   SWIG_CSharpIOException,
 179   SWIG_CSharpNullReferenceException,
 180   SWIG_CSharpOutOfMemoryException,
 181   SWIG_CSharpOverflowException,
 182   SWIG_CSharpSystemException
 183 } SWIG_CSharpExceptionCodes;
 184
 185 typedef enum {
 186   SWIG_CSharpArgumentException,
 187   SWIG_CSharpArgumentNullException,
 188   SWIG_CSharpArgumentOutOfRangeException
 189 } SWIG_CSharpExceptionArgumentCodes;
 190
 191 typedef void (SWIGSTDCALL* SWIG_CSharpExceptionCallback_t)(const char *);
 192 typedef void (SWIGSTDCALL* SWIG_CSharpExceptionArgumentCallback_t)(const char *, const char *);
 193
 194 typedef struct {
 195   SWIG_CSharpExceptionCodes code;
 196   SWIG_CSharpExceptionCallback_t callback;
 197 } SWIG_CSharpException_t;
 198
 199 typedef struct {
 200   SWIG_CSharpExceptionArgumentCodes code;
 201   SWIG_CSharpExceptionArgumentCallback_t callback;
 202 } SWIG_CSharpExceptionArgument_t;
 203
 204 SWIG_CSharpException_t SWIG_csharp_exceptions[] = {
 205   { SWIG_CSharpApplicationException, NULL },
 206   { SWIG_CSharpArithmeticException, NULL },
 207   { SWIG_CSharpDivideByZeroException, NULL },
 208   { SWIG_CSharpIndexOutOfRangeException, NULL },
 209   { SWIG_CSharpInvalidCastException, NULL },
 210   { SWIG_CSharpInvalidOperationException, NULL },
 211   { SWIG_CSharpIOException, NULL },
 212   { SWIG_CSharpNullReferenceException, NULL },
 213   { SWIG_CSharpOutOfMemoryException, NULL },
 214   { SWIG_CSharpOverflowException, NULL },
 215   { SWIG_CSharpSystemException, NULL }
 216 };
 217
 218 SWIG_CSharpExceptionArgument_t SWIG_csharp_exceptions_argument[] = {
 219   { SWIG_CSharpArgumentException, NULL },
 220   { SWIG_CSharpArgumentNullException, NULL },
 221   { SWIG_CSharpArgumentOutOfRangeException, NULL }
 222 };
 223
 224 void SWIGUNUSED SWIG_CSharpSetPendingException(SWIG_CSharpExceptionCodes code, const char *msg) {
 225   SWIG_CSharpExceptionCallback_t callback = SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback;
 226   if ((size_t)code < sizeof(SWIG_csharp_exceptions)/sizeof(SWIG_CSharpException_t)) {
 227     callback = SWIG_csharp_exceptions[code].callback;
 228   }
 229   callback(msg);
 230 }
 231
 232 void SWIGUNUSED SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpExceptionArgumentCodes code, const char *msg, const char *param_name) {
 233   SWIG_CSharpExceptionArgumentCallback_t callback = SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback;
 234   if ((size_t)code < sizeof(SWIG_csharp_exceptions_argument)/sizeof(SWIG_CSharpExceptionArgument_t)) {
 235     callback = SWIG_csharp_exceptions_argument[code].callback;
 236   }
 237   callback(msg, param_name);
 238 }
 239
 240
 241 #ifdef __cplusplus
 242 extern "C"
 243 #endif
 244 SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionCallbacks_NDalic(
 245                                                 SWIG_CSharpExceptionCallback_t applicationCallback,
 246                                                 SWIG_CSharpExceptionCallback_t arithmeticCallback,
 247                                                 SWIG_CSharpExceptionCallback_t divideByZeroCallback,
 248                                                 SWIG_CSharpExceptionCallback_t indexOutOfRangeCallback,
 249                                                 SWIG_CSharpExceptionCallback_t invalidCastCallback,
 250                                                 SWIG_CSharpExceptionCallback_t invalidOperationCallback,
 251                                                 SWIG_CSharpExceptionCallback_t ioCallback,
 252                                                 SWIG_CSharpExceptionCallback_t nullReferenceCallback,
 253                                                 SWIG_CSharpExceptionCallback_t outOfMemoryCallback,
 254                                                 SWIG_CSharpExceptionCallback_t overflowCallback,
 255                                                 SWIG_CSharpExceptionCallback_t systemCallback) {
 256   SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback = applicationCallback;
 257   SWIG_csharp_exceptions[SWIG_CSharpArithmeticException].callback = arithmeticCallback;
 258   SWIG_csharp_exceptions[SWIG_CSharpDivideByZeroException].callback = divideByZeroCallback;
 259   SWIG_csharp_exceptions[SWIG_CSharpIndexOutOfRangeException].callback = indexOutOfRangeCallback;
 260   SWIG_csharp_exceptions[SWIG_CSharpInvalidCastException].callback = invalidCastCallback;
 261   SWIG_csharp_exceptions[SWIG_CSharpInvalidOperationException].callback = invalidOperationCallback;
 262   SWIG_csharp_exceptions[SWIG_CSharpIOException].callback = ioCallback;
 263   SWIG_csharp_exceptions[SWIG_CSharpNullReferenceException].callback = nullReferenceCallback;
 264   SWIG_csharp_exceptions[SWIG_CSharpOutOfMemoryException].callback = outOfMemoryCallback;
 265   SWIG_csharp_exceptions[SWIG_CSharpOverflowException].callback = overflowCallback;
 266   SWIG_csharp_exceptions[SWIG_CSharpSystemException].callback = systemCallback;
 267 }
 268
 269 #ifdef __cplusplus
 270 extern "C"
 271 #endif
 272 SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionArgumentCallbacks_NDalic(
 273                                                 SWIG_CSharpExceptionArgumentCallback_t argumentCallback,
 274                                                 SWIG_CSharpExceptionArgumentCallback_t argumentNullCallback,
 275                                                 SWIG_CSharpExceptionArgumentCallback_t argumentOutOfRangeCallback) {
 276   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback = argumentCallback;
 277   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentNullException].callback = argumentNullCallback;
 278   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentOutOfRangeException].callback = argumentOutOfRangeCallback;
 279 }
 280
 281
 282 /* Callback for returning strings to C# without leaking memory */
 283 typedef char * (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char *);
 284 SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback = NULL;
 285
 286 // keep argWidgetCs and argWidgetV so they're always available to DALi
 287 int argWidgetC = 1;
 288 char **argWidgetV = NULL;
 289
 290 #ifdef __cplusplus
 291 extern "C"
 292 #endif
 293 SWIGEXPORT void SWIGSTDCALL SWIGRegisterStringCallback_NDalic(SWIG_CSharpStringHelperCallback callback) {
 294   SWIG_csharp_string_callback = callback;
 295 }
 296
 297
 298 /* Contract support */
 299
 300 #define SWIG_contract_assert(nullreturn, expr, msg) if (!(expr)) {SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, msg, ""); return nullreturn; } else
 301
 302 /*  Errors in SWIG */
 303 #define  SWIG_UnknownError         -1
 304 #define  SWIG_IOError              -2
 305 #define  SWIG_RuntimeError         -3
 306 #define  SWIG_IndexError           -4
 307 #define  SWIG_TypeError            -5
 308 #define  SWIG_DivisionByZero       -6
 309 #define  SWIG_OverflowError        -7
 310 #define  SWIG_SyntaxError          -8
 311 #define  SWIG_ValueError           -9
 312 #define  SWIG_SystemError          -10
 313 #define  SWIG_AttributeError       -11
 314 #define  SWIG_MemoryError          -12
 315 #define  SWIG_NullReferenceError   -13
 316
 317
 318 /* -----------------------------------------------------------------------------
 319  * director_common.swg
 320  *
 321  * This file contains support for director classes which is common between
 322  * languages.
 323  * ----------------------------------------------------------------------------- */
 324
 325 /*
 326   Use -DSWIG_DIRECTOR_STATIC if you prefer to avoid the use of the
 327   'Swig' namespace. This could be useful for multi-modules projects.
 328 */
 329 #ifdef SWIG_DIRECTOR_STATIC
 330 /* Force anonymous (static) namespace */
 331 #define Swig
 332 #endif
 333 /* -----------------------------------------------------------------------------
 334  * director.swg
 335  *
 336  * This file contains support for director classes so that C# proxy
 337  * methods can be called from C++.
 338  * ----------------------------------------------------------------------------- */
 339
 340 #if defined(DEBUG_DIRECTOR_OWNED)
 341 #include <iostream>
 342 #endif
 343 #include <string>
 344 #include <exception>
 345
 346 namespace Swig {
 347   /* Director base class - not currently used in C# directors */
 348   class Director {
 349   };
 350
 351   /* Base class for director exceptions */
 352   class DirectorException : public std::exception {
 353   protected:
 354     std::string swig_msg;
 355
 356   public:
 357     DirectorException(const char *msg) : swig_msg(msg) {
 358     }
 359
 360     DirectorException(const std::string &msg) : swig_msg(msg) {
 361     }
 362
 363     virtual ~DirectorException() throw() {
 364     }
 365
 366     const char *what() const throw() {
 367       return swig_msg.c_str();
 368     }
 369   };
 370
 371   /* Pure virtual method exception */
 372   class DirectorPureVirtualException : public DirectorException {
 373   public:
 374     DirectorPureVirtualException(const char *msg) : DirectorException(std::string("Attempt to invoke pure virtual method ") + msg) {
 375     }
 376   };
 377 }
 378
 379
 380 void SWIG_CSharpException(int code, const char *msg) {
 381   if (code == SWIG_ValueError) {
 382     SWIG_CSharpExceptionArgumentCodes exception_code = SWIG_CSharpArgumentOutOfRangeException;
 383     SWIG_CSharpSetPendingExceptionArgument(exception_code, msg, 0);
 384   } else {
 385     SWIG_CSharpExceptionCodes exception_code = SWIG_CSharpApplicationException;
 386     switch(code) {
 387     case SWIG_MemoryError:
 388       exception_code = SWIG_CSharpOutOfMemoryException;
 389       break;
 390     case SWIG_IndexError:
 391       exception_code = SWIG_CSharpIndexOutOfRangeException;
 392       break;
 393     case SWIG_DivisionByZero:
 394       exception_code = SWIG_CSharpDivideByZeroException;
 395       break;
 396     case SWIG_IOError:
 397       exception_code = SWIG_CSharpIOException;
 398       break;
 399     case SWIG_OverflowError:
 400       exception_code = SWIG_CSharpOverflowException;
 401       break;
 402     case SWIG_RuntimeError:
 403     case SWIG_TypeError:
 404     case SWIG_SyntaxError:
 405     case SWIG_SystemError:
 406     case SWIG_UnknownError:
 407     default:
 408       exception_code = SWIG_CSharpApplicationException;
 409       break;
 410     }
 411     SWIG_CSharpSetPendingException(exception_code, msg);
 412   }
 413 }
 414
 415
 416 #include <stdexcept>
 417
 418
 419 #define SWIGSTDCALL
 420
 421 #include <time.h>
 422
 423 #include <dali/dali.h>
 424 #include <dali-toolkit/dali-toolkit.h>
 425
 426 #include <dali/devel-api/actors/actor-devel.h>
 427 #include <dali/devel-api/common/stage-devel.h>
 428 #include <dali/devel-api/events/key-event-devel.h>
 429 #include <dali/devel-api/events/wheel-event-devel.h>
 430 #include <dali/devel-api/events/key-event-devel.h>
 431 #include <dali/devel-api/events/touch-point.h>
 432
 433 #include <dali/public-api/math/matrix.h>
 434 #include <dali/public-api/math/matrix3.h>
 435 #include <dali/public-api/math/viewport.h>
 436 #include <dali/public-api/object/property-key.h>
 437 #include <dali/devel-api/object/csharp-type-info.h>
 438 #include <dali/devel-api/object/csharp-type-registry.h>
 439
 440 #include <dali/public-api/adaptor-framework/timer.h>
 441 #include <dali/public-api/adaptor-framework/style-change.h>
 442 #include <dali/devel-api/adaptor-framework/environment-variable.h>
 443
 444 #include <dali-toolkit/devel-api/accessibility-manager/accessibility-manager.h>
 445
 446 #include <dali-toolkit/devel-api/builder/builder.h>
 447
 448 #include <dali-toolkit/devel-api/focus-manager/keyinput-focus-manager.h>
 449 #include <dali-toolkit/devel-api/focus-manager/keyboard-focus-manager-devel.h>
 450
 451 #include <dali-toolkit/devel-api/controls/control-devel.h>
 452 #include <dali-toolkit/devel-api/controls/popup/popup.h>
 453 #include <dali-toolkit/devel-api/controls/gaussian-blur-view/gaussian-blur-view.h>
 454 #include <dali-toolkit/devel-api/controls/page-turn-view/page-factory.h>
 455 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-view.h>
 456 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-landscape-view.h>
 457 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-portrait-view.h>
 458 #include <dali-toolkit/devel-api/controls/buttons/toggle-button.h>
 459 #include <dali-toolkit/devel-api/controls/alignment/alignment.h>
 460 #include <dali-toolkit/devel-api/controls/scroll-bar/scroll-bar.h>
 461 #include <dali-toolkit/devel-api/controls/table-view/table-view.h>
 462
 463 #include <dali-toolkit/devel-api/visual-factory/visual-base.h>
 464 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
 465 #include <dali-toolkit/devel-api/visual-factory/transition-data.h>
 466
 467 #include <dali-toolkit/public-api/visuals/visual-properties.h>
 468 #include <dali-toolkit/public-api/visuals/text-visual-properties.h>
 469 #include <dali-toolkit/public-api/visuals/image-visual-properties.h>
 470
 471 #include <dali-toolkit/devel-api/controls/tooltip/tooltip-properties.h>
 472 #include <dali-toolkit/devel-api/visuals/image-visual-properties-devel.h>
 473 #include <dali-toolkit/devel-api/controls/control-depth-index-ranges.h>
 474
 475 #include <dali-toolkit/public-api/controls/scrollable/item-view/item-view-declarations.h>
 476
 477 #include <dali/devel-api/adaptor-framework/pixel-buffer.h>
 478 #include <dali/devel-api/adaptor-framework/image-loading.h>
 479
 480 #include <dali/public-api/events/mouse-button.h>
 481
 482 #include <dali-toolkit/devel-api/controls/web-view/web-view.h>
 483 #include "web-view-signal-converter.h"
 484
 485 #include <dali/integration-api/debug.h>
 486
 487 #include <dali-toolkit/devel-api/controls/video-view/video-view-devel.h>
 488
 489 #include <dali/devel-api/adaptor-framework/native-image-source-devel.h>
 490
 491 #include <dali-toolkit/devel-api/text/rendering-backend.h>
 492
 493
 494 #include <dali/devel-api/update/frame-callback-interface.h>
 495 #include <dali/devel-api/update/update-proxy.h>
 496
 497
 498 // add here SWIG version check
 499
 500 #if defined(_MSC_VER)         // Microsoft Visual C++ 6.0
 501 // disable Swig-dependent warnings
 502
 503 // 'identifier1' has C-linkage specified,
 504 // but returns UDT 'identifier2' which is incompatible with C
 505 #pragma warning(disable: 4190)
 506
 507 // 'int' : forcing value to bool 'true' or 'false' (performance warning)
 508 #pragma warning(disable: 4800)
 509
 510 // debug info too long etc etc
 511 #pragma warning(disable: 4786)
 512 #endif
 513
 514
 515 #include <stdexcept>
 516
 517
 518 #include <string>
 519
 520
 521 #include <vector>
 522 #include <algorithm>
 523 #include <stdexcept>
 524
 525
 526 #include <map>
 527 #include <algorithm>
 528 #include <stdexcept>
 529
 530
 531 #include <utility>
 532
 533
 534 typedef float floatp;
 535
 536 SWIGINTERN floatp *new_floatp(){
 537   return new float();
 538 }
 539 SWIGINTERN void delete_floatp(floatp *self){
 540   if (self) delete self;
 541 }
 542 SWIGINTERN void floatp_assign(floatp *self,float value){
 543   *self = value;
 544 }
 545 SWIGINTERN float floatp_value(floatp *self){
 546   return *self;
 547 }
 548 SWIGINTERN float *floatp_cast(floatp *self){
 549   return self;
 550 }
 551 SWIGINTERN floatp *floatp_frompointer(float *t){
 552   return (floatp *) t;
 553 }
 554
 555 typedef int intp;
 556
 557 SWIGINTERN intp *new_intp(){
 558   return new int();
 559 }
 560 SWIGINTERN void delete_intp(intp *self){
 561   if (self) delete self;
 562 }
 563 SWIGINTERN void intp_assign(intp *self,int value){
 564   *self = value;
 565 }
 566 SWIGINTERN int intp_value(intp *self){
 567   return *self;
 568 }
 569 SWIGINTERN int *intp_cast(intp *self){
 570   return self;
 571 }
 572 SWIGINTERN intp *intp_frompointer(int *t){
 573   return (intp *) t;
 574 }
 575
 576 typedef double doublep;
 577
 578 SWIGINTERN doublep *new_doublep(){
 579   return new double();
 580 }
 581 SWIGINTERN void delete_doublep(doublep *self){
 582   if (self) delete self;
 583 }
 584 SWIGINTERN void doublep_assign(doublep *self,double value){
 585   *self = value;
 586 }
 587 SWIGINTERN double doublep_value(doublep *self){
 588   return *self;
 589 }
 590 SWIGINTERN double *doublep_cast(doublep *self){
 591   return self;
 592 }
 593 SWIGINTERN doublep *doublep_frompointer(double *t){
 594   return (doublep *) t;
 595 }
 596
 597 typedef unsigned int uintp;
 598
 599 SWIGINTERN uintp *new_uintp(){
 600   return new unsigned int();
 601 }
 602 SWIGINTERN void delete_uintp(uintp *self){
 603   if (self) delete self;
 604 }
 605 SWIGINTERN void uintp_assign(uintp *self,unsigned int value){
 606   *self = value;
 607 }
 608 SWIGINTERN unsigned int uintp_value(uintp *self){
 609   return *self;
 610 }
 611 SWIGINTERN unsigned int *uintp_cast(uintp *self){
 612   return self;
 613 }
 614 SWIGINTERN uintp *uintp_frompointer(unsigned int *t){
 615   return (uintp *) t;
 616 }
 617
 618 typedef unsigned short ushortp;
 619
 620 SWIGINTERN ushortp *new_ushortp(){
 621   return new unsigned short();
 622 }
 623 SWIGINTERN void delete_ushortp(ushortp *self){
 624   if (self) delete self;
 625 }
 626 SWIGINTERN void ushortp_assign(ushortp *self,unsigned short value){
 627   *self = value;
 628 }
 629 SWIGINTERN unsigned short ushortp_value(ushortp *self){
 630   return *self;
 631 }
 632 SWIGINTERN unsigned short *ushortp_cast(ushortp *self){
 633   return self;
 634 }
 635 SWIGINTERN ushortp *ushortp_frompointer(unsigned short *t){
 636   return (ushortp *) t;
 637 }
 638
 639 unsigned int int_to_uint(int x) {
 640    return (unsigned int) x;
 641 }
 642
 643
 644 #define CALL_CATCH_EXCEPTION(ret)          \
 645          catch (std::out_of_range& e)            \
 646          {                                                                                                                                  \
 647              SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));   \
 648              return ret;\
 649           }                                                                                                                                 \
 650           catch (std::exception& e)                                                                                         \
 651           {                                                                                                                                 \
 652             SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));\
 653             return ret;\
 654           }                                                                                                                                 \
 655           catch (DaliException e)                                                                                            \
 656           {                                                                                                                                 \
 657             SWIG_CSharpException(SWIG_UnknownError, e.condition);                            \
 658             return ret;\
 659           }                                                                                                                                 \
 660           catch (...)                                                                                                                  \
 661           {                                                                                                                                 \
 662             SWIG_CSharpException(SWIG_UnknownError, "unknown error");                  \
 663             return ret;\
 664           }
 665
 666
 667
 668 using namespace Dali;
 669 using namespace Dali::Toolkit;
 670
 671 SWIGINTERN bool Dali_BaseHandle_HasBody(Dali::BaseHandle const *self)
 672 {
 673   bool result = false;
 674   try
 675   {
 676     // C++ code. DALi uses Handle <-> Body design pattern.
 677     // This function checks the Handle to see if it has a body attached ( possible to have empty handles).
 678     // Handles in DALi can be converted into a boolean type
 679     // to check if the handle has a valid body attached to it.
 680     // Internally checking *self will  checks IntrusivePtr<Dali::RefObject> mObjectHandle in BaseHandle;
 681     if( *self )
 682     {
 683       result = true;
 684     }
 685     else
 686     {
 687       result = false;
 688     }
 689   }
 690   CALL_CATCH_EXCEPTION(false);
 691   return result;
 692 }
 693
 694 SWIGINTERN bool Dali_BaseHandle_IsEqual(Dali::BaseHandle const *self,Dali::BaseHandle const &rhs)
 695 {
 696   bool result = false;
 697   try
 698   {
 699     // C++ code. Check if two handles reference the same implemtion
 700     if( *self == rhs)
 701     {
 702       result = true;
 703     }
 704     else
 705     {
 706       result = false;
 707     }
 708   }
 709   CALL_CATCH_EXCEPTION(false);
 710   return result;
 711 }
 712
 713
 714 SWIGINTERN void Dali_TypeRegistration_RegisterControl(std::string const &controlName,Dali::CSharpTypeInfo::CreateFunction createFunc){
 715      Dali::CSharpTypeRegistry::RegisterType( controlName, typeid( Dali::Toolkit::Control), createFunc );
 716    }
 717 SWIGINTERN void Dali_TypeRegistration_RegisterProperty(std::string const &controlName,std::string const &propertyName,int index,Dali::Property::Type type,Dali::CSharpTypeInfo::SetPropertyFunction setFunc,Dali::CSharpTypeInfo::GetPropertyFunction getFunc){
 718      Dali::CSharpTypeRegistry::RegisterProperty( controlName, propertyName, index, type, setFunc, getFunc );
 719    }
 720 SWIGINTERN std::vector< Dali::TouchPoint > *new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(int capacity){
 721         std::vector< Dali::TouchPoint >* pv = 0;
 722         if (capacity >= 0) {
 723           pv = new std::vector< Dali::TouchPoint >();
 724           pv->reserve(capacity);
 725        } else {
 726           throw std::out_of_range("capacity");
 727        }
 728        return pv;
 729       }
 730 SWIGINTERN Dali::TouchPoint std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(std::vector< Dali::TouchPoint > *self,int index){
 731         if (index>=0 && index<(int)self->size())
 732           return (*self)[index];
 733         else
 734           throw std::out_of_range("index");
 735       }
 736 SWIGINTERN Dali::TouchPoint const &std_vector_Sl_Dali_TouchPoint_Sg__getitem(std::vector< Dali::TouchPoint > *self,int index){
 737         if (index>=0 && index<(int)self->size())
 738           return (*self)[index];
 739         else
 740           throw std::out_of_range("index");
 741       }
 742 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__setitem(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &val){
 743         if (index>=0 && index<(int)self->size())
 744           (*self)[index] = val;
 745         else
 746           throw std::out_of_range("index");
 747       }
 748 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__AddRange(std::vector< Dali::TouchPoint > *self,std::vector< Dali::TouchPoint > const &values){
 749         self->insert(self->end(), values.begin(), values.end());
 750       }
 751 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__GetRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 752         if (index < 0)
 753           throw std::out_of_range("index");
 754         if (count < 0)
 755           throw std::out_of_range("count");
 756         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 757           throw std::invalid_argument("invalid range");
 758         return new std::vector< Dali::TouchPoint >(self->begin()+index, self->begin()+index+count);
 759       }
 760 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Insert(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &x){
 761         if (index>=0 && index<(int)self->size()+1)
 762           self->insert(self->begin()+index, x);
 763         else
 764           throw std::out_of_range("index");
 765       }
 766 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 767         if (index>=0 && index<(int)self->size()+1)
 768           self->insert(self->begin()+index, values.begin(), values.end());
 769         else
 770           throw std::out_of_range("index");
 771       }
 772 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(std::vector< Dali::TouchPoint > *self,int index){
 773         if (index>=0 && index<(int)self->size())
 774           self->erase(self->begin() + index);
 775         else
 776           throw std::out_of_range("index");
 777       }
 778 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 779         if (index < 0)
 780           throw std::out_of_range("index");
 781         if (count < 0)
 782           throw std::out_of_range("count");
 783         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 784           throw std::invalid_argument("invalid range");
 785         self->erase(self->begin()+index, self->begin()+index+count);
 786       }
 787 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__Repeat(Dali::TouchPoint const &value,int count){
 788         if (count < 0)
 789           throw std::out_of_range("count");
 790         return new std::vector< Dali::TouchPoint >(count, value);
 791       }
 792 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(std::vector< Dali::TouchPoint > *self){
 793         std::reverse(self->begin(), self->end());
 794       }
 795 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(std::vector< Dali::TouchPoint > *self,int index,int count){
 796         if (index < 0)
 797           throw std::out_of_range("index");
 798         if (count < 0)
 799           throw std::out_of_range("count");
 800         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 801           throw std::invalid_argument("invalid range");
 802         std::reverse(self->begin()+index, self->begin()+index+count);
 803       }
 804 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__SetRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 805         if (index < 0)
 806           throw std::out_of_range("index");
 807         if (index+values.size() > self->size())
 808           throw std::out_of_range("index");
 809         std::copy(values.begin(), values.end(), self->begin()+index);
 810       }
 811 SWIGINTERN bool Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty(Dali::Signal< void (float) > const *self){
 812          return self->Empty();
 813       }
 814 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount(Dali::Signal< void (float) > const *self){
 815         return self->GetConnectionCount();
 816       }
 817 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(Dali::Signal< void (float) > *self,void (*func)(float)){
 818           self->Connect( func );
 819       }
 820 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(Dali::Signal< void (float) > *self,void (*func)(float)){
 821           self->Disconnect( func );
 822       }
 823 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(Dali::Signal< void (float) > *self,float arg){
 824           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 825 /*@SWIG@*/ self->Emit( arg );
 826       }
 827 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty(Dali::Signal< void (Dali::BaseHandle) > const *self){
 828          return self->Empty();
 829       }
 830 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::BaseHandle) > const *self){
 831         return self->GetConnectionCount();
 832       }
 833 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 834           self->Connect( func );
 835       }
 836 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 837           self->Disconnect( func );
 838       }
 839 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(Dali::Signal< void (Dali::BaseHandle) > *self,Dali::BaseHandle arg){
 840           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 841 /*@SWIG@*/ self->Emit( arg );
 842       }
 843 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::RefObject const *) > const *self){
 844          return self->Empty();
 845       }
 846 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::RefObject const *) > const *self){
 847         return self->GetConnectionCount();
 848       }
 849 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(Dali::Signal< void (Dali::RefObject const *) > *self,void (*func)(Dali::RefObject const *)){
 850           self->Connect( func );
 851       }
 852 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(Dali::Signal< void (Dali::RefObject const *) > *self,void (*func)(Dali::RefObject const *)){
 853           self->Disconnect( func );
 854       }
 855 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(Dali::Signal< void (Dali::RefObject const *) > *self,Dali::RefObject const *arg){
 856           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 857 /*@SWIG@*/ self->Emit( arg );
 858       }
 859 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 860          return self->Empty();
 861       }
 862 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 863         return self->GetConnectionCount();
 864       }
 865 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 866           self->Connect( func );
 867       }
 868 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 869           self->Disconnect( func );
 870       }
 871 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(Dali::Signal< void (Dali::PropertyNotification &) > *self,Dali::PropertyNotification &arg){
 872           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 873 /*@SWIG@*/ self->Emit( arg );
 874       }
 875 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > const *self){
 876          return self->Empty();
 877       }
 878 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > const *self){
 879         return self->GetConnectionCount();
 880       }
 881 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *self,void (*func)(Dali::Actor,Dali::LongPressGesture const &)){
 882         self->Connect( func );
 883       }
 884 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *self,void (*func)(Dali::Actor,Dali::LongPressGesture const &)){
 885         self->Disconnect( func );
 886       }
 887 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *self,Dali::Actor arg1,Dali::LongPressGesture const &arg2){
 888         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 889 /*@SWIG@*/ self->Emit( arg1, arg2 );
 890       }
 891 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > const *self){
 892          return self->Empty();
 893       }
 894 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > const *self){
 895         return self->GetConnectionCount();
 896       }
 897 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *self,bool (*func)(Dali::Actor,Dali::TouchEvent const &)){
 898         self->Connect( func );
 899       }
 900 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *self,bool (*func)(Dali::Actor,Dali::TouchEvent const &)){
 901         self->Disconnect( func );
 902       }
 903 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *self,Dali::Actor arg1,Dali::TouchEvent const &arg2){
 904         return self->Emit( arg1, arg2 );
 905       }
 906 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > const *self){
 907          return self->Empty();
 908       }
 909 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > const *self){
 910         return self->GetConnectionCount();
 911       }
 912 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *self,bool (*func)(Dali::Actor,Dali::HoverEvent const &)){
 913         self->Connect( func );
 914       }
 915 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *self,bool (*func)(Dali::Actor,Dali::HoverEvent const &)){
 916         self->Disconnect( func );
 917       }
 918 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *self,Dali::Actor arg1,Dali::HoverEvent const &arg2){
 919         return self->Emit( arg1, arg2 );
 920       }
 921 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > const *self){
 922          return self->Empty();
 923       }
 924 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > const *self){
 925         return self->GetConnectionCount();
 926       }
 927 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *self,bool (*func)(Dali::Actor,Dali::WheelEvent const &)){
 928         self->Connect( func );
 929       }
 930 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *self,bool (*func)(Dali::Actor,Dali::WheelEvent const &)){
 931         self->Disconnect( func );
 932       }
 933 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *self,Dali::Actor arg1,Dali::WheelEvent const &arg2){
 934         return self->Emit( arg1, arg2 );
 935       }
 936 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor) > const *self){
 937          return self->Empty();
 938       }
 939 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor) > const *self){
 940         return self->GetConnectionCount();
 941       }
 942 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 943           self->Connect( func );
 944       }
 945 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 946           self->Disconnect( func );
 947       }
 948 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor) > *self,Dali::Actor arg){
 949           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 950 /*@SWIG@*/ self->Emit( arg );
 951       }
 952 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 953          return self->Empty();
 954       }
 955 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 956         return self->GetConnectionCount();
 957       }
 958 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::KeyEvent const &) > *self,void (*func)(Dali::KeyEvent const &)){
 959           self->Connect( func );
 960       }
 961 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::KeyEvent const &) > *self,void (*func)(Dali::KeyEvent const &)){
 962           self->Disconnect( func );
 963       }
 964 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::KeyEvent const &) > *self,Dali::KeyEvent const &arg){
 965           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 966 /*@SWIG@*/ self->Emit( arg );
 967       }
 968 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::TouchEvent const &) > const *self){
 969          return self->Empty();
 970       }
 971 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::TouchEvent const &) > const *self){
 972         return self->GetConnectionCount();
 973       }
 974 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::TouchEvent const &) > *self,void (*func)(Dali::TouchEvent const &)){
 975           self->Connect( func );
 976       }
 977 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::TouchEvent const &) > *self,void (*func)(Dali::TouchEvent const &)){
 978           self->Disconnect( func );
 979       }
 980 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::TouchEvent const &) > *self,Dali::TouchEvent const &arg){
 981           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 982 /*@SWIG@*/ self->Emit( arg );
 983       }
 984 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
 985          return self->Empty();
 986       }
 987 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
 988         return self->GetConnectionCount();
 989       }
 990 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::WheelEvent const &) > *self,void (*func)(Dali::WheelEvent const &)){
 991           self->Connect( func );
 992       }
 993 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::WheelEvent const &) > *self,void (*func)(Dali::WheelEvent const &)){
 994           self->Disconnect( func );
 995       }
 996 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::WheelEvent const &) > *self,Dali::WheelEvent const &arg){
 997           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 998 /*@SWIG@*/ self->Emit( arg );
 999       }
1000 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > const *self){
1001          return self->Empty();
1002       }
1003 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > const *self){
1004         return self->GetConnectionCount();
1005       }
1006 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *self,void (*func)(Dali::Actor,Dali::PanGesture const &)){
1007         self->Connect( func );
1008       }
1009 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *self,void (*func)(Dali::Actor,Dali::PanGesture const &)){
1010         self->Disconnect( func );
1011       }
1012 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *self,Dali::Actor arg1,Dali::PanGesture const &arg2){
1013         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1014 /*@SWIG@*/ self->Emit( arg1, arg2 );
1015       }
1016 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > const *self){
1017          return self->Empty();
1018       }
1019 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > const *self){
1020         return self->GetConnectionCount();
1021       }
1022 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *self,void (*func)(Dali::Actor,Dali::PinchGesture const &)){
1023         self->Connect( func );
1024       }
1025 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *self,void (*func)(Dali::Actor,Dali::PinchGesture const &)){
1026         self->Disconnect( func );
1027       }
1028 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *self,Dali::Actor arg1,Dali::PinchGesture const &arg2){
1029         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1030 /*@SWIG@*/ self->Emit( arg1, arg2 );
1031       }
1032 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > const *self){
1033          return self->Empty();
1034       }
1035 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > const *self){
1036         return self->GetConnectionCount();
1037       }
1038 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *self,void (*func)(Dali::Actor,Dali::TapGesture const &)){
1039         self->Connect( func );
1040       }
1041 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *self,void (*func)(Dali::Actor,Dali::TapGesture const &)){
1042         self->Disconnect( func );
1043       }
1044 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *self,Dali::Actor arg1,Dali::TapGesture const &arg2){
1045         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1046 /*@SWIG@*/ self->Emit( arg1, arg2 );
1047       }
1048 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Empty(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > const *self){
1049          return self->Empty();
1050       }
1051 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > const *self){
1052         return self->GetConnectionCount();
1053       }
1054 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Connect(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *self,void (*func)(Dali::Actor, Dali::LayoutDirection::Type)){
1055           return self->Connect( func );
1056       }
1057 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *self,void (*func)(Dali::Actor, Dali::LayoutDirection::Type)){
1058           self->Disconnect( func );
1059       }
1060 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Emit(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *self,Dali::Actor arg1, Dali::LayoutDirection::Type arg3){
1061           self->Emit( arg1, arg3 );
1062       }
1063 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > const *self){
1064          return self->Empty();
1065       }
1066 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > const *self){
1067         return self->GetConnectionCount();
1068       }
1069 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *self,void (*func)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)){
1070           return self->Connect( func );
1071       }
1072 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *self,void (*func)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)){
1073           self->Disconnect( func );
1074       }
1075 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *self,Dali::Actor arg1,bool arg2,Dali::DevelActor::VisibilityChange::Type arg3){
1076           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1077 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1078       }
1079
1080 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Empty(Dali::Signal< bool () > const *self){
1081          return self->Empty();
1082       }
1083 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount(Dali::Signal< bool () > const *self){
1084         return self->GetConnectionCount();
1085       }
1086 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(Dali::Signal< bool () > *self,bool (*func)()){
1087           self->Connect( func );
1088       }
1089 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(Dali::Signal< bool () > *self,bool (*func)()){
1090           self->Disconnect( func );
1091       }
1092 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(Dali::Signal< bool () > *self){
1093           return self->Emit();
1094       }
1095
1096 SWIGINTERN std::vector< unsigned int > *new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(int capacity){
1097         std::vector< unsigned int >* pv = 0;
1098         if (capacity >= 0) {
1099           pv = new std::vector< unsigned int >();
1100           pv->reserve(capacity);
1101        } else {
1102           throw std::out_of_range("capacity");
1103        }
1104        return pv;
1105       }
1106 SWIGINTERN unsigned int std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(std::vector< unsigned int > *self,int index){
1107         if (index>=0 && index<(int)self->size())
1108           return (*self)[index];
1109         else
1110           throw std::out_of_range("index");
1111       }
1112 SWIGINTERN unsigned int const &std_vector_Sl_unsigned_SS_int_Sg__getitem(std::vector< unsigned int > *self,int index){
1113         if (index>=0 && index<(int)self->size())
1114           return (*self)[index];
1115         else
1116           throw std::out_of_range("index");
1117       }
1118 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__setitem(std::vector< unsigned int > *self,int index,unsigned int const &val){
1119         if (index>=0 && index<(int)self->size())
1120           (*self)[index] = val;
1121         else
1122           throw std::out_of_range("index");
1123       }
1124 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__AddRange(std::vector< unsigned int > *self,std::vector< unsigned int > const &values){
1125         self->insert(self->end(), values.begin(), values.end());
1126       }
1127 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__GetRange(std::vector< unsigned int > *self,int index,int count){
1128         if (index < 0)
1129           throw std::out_of_range("index");
1130         if (count < 0)
1131           throw std::out_of_range("count");
1132         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1133           throw std::invalid_argument("invalid range");
1134         return new std::vector< unsigned int >(self->begin()+index, self->begin()+index+count);
1135       }
1136 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Insert(std::vector< unsigned int > *self,int index,unsigned int const &x){
1137         if (index>=0 && index<(int)self->size()+1)
1138           self->insert(self->begin()+index, x);
1139         else
1140           throw std::out_of_range("index");
1141       }
1142 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__InsertRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1143         if (index>=0 && index<(int)self->size()+1)
1144           self->insert(self->begin()+index, values.begin(), values.end());
1145         else
1146           throw std::out_of_range("index");
1147       }
1148 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(std::vector< unsigned int > *self,int index){
1149         if (index>=0 && index<(int)self->size())
1150           self->erase(self->begin() + index);
1151         else
1152           throw std::out_of_range("index");
1153       }
1154 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(std::vector< unsigned int > *self,int index,int count){
1155         if (index < 0)
1156           throw std::out_of_range("index");
1157         if (count < 0)
1158           throw std::out_of_range("count");
1159         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1160           throw std::invalid_argument("invalid range");
1161         self->erase(self->begin()+index, self->begin()+index+count);
1162       }
1163 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__Repeat(unsigned int const &value,int count){
1164         if (count < 0)
1165           throw std::out_of_range("count");
1166         return new std::vector< unsigned int >(count, value);
1167       }
1168 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(std::vector< unsigned int > *self){
1169         std::reverse(self->begin(), self->end());
1170       }
1171 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(std::vector< unsigned int > *self,int index,int count){
1172         if (index < 0)
1173           throw std::out_of_range("index");
1174         if (count < 0)
1175           throw std::out_of_range("count");
1176         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1177           throw std::invalid_argument("invalid range");
1178         std::reverse(self->begin()+index, self->begin()+index+count);
1179       }
1180 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__SetRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1181         if (index < 0)
1182           throw std::out_of_range("index");
1183         if (index+values.size() > self->size())
1184           throw std::out_of_range("index");
1185         std::copy(values.begin(), values.end(), self->begin()+index);
1186       }
1187 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Contains(std::vector< unsigned int > *self,unsigned int const &value){
1188         return std::find(self->begin(), self->end(), value) != self->end();
1189       }
1190 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__IndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1191         int index = -1;
1192         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1193         if (it != self->end())
1194           index = (int)(it - self->begin());
1195         return index;
1196       }
1197 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1198         int index = -1;
1199         std::vector< unsigned int >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
1200         if (rit != self->rend())
1201           index = (int)(self->rend() - 1 - rit);
1202         return index;
1203       }
1204 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Remove(std::vector< unsigned int > *self,unsigned int const &value){
1205         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1206         if (it != self->end()) {
1207           self->erase(it);
1208           return true;
1209         }
1210         return false;
1211       }
1212 SWIGINTERN std::vector< std::pair< unsigned int,Dali::Actor > > *new_std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg___SWIG_2(int capacity){
1213         std::vector< std::pair< unsigned int,Dali::Actor > >* pv = 0;
1214         if (capacity >= 0) {
1215           pv = new std::vector< std::pair< unsigned int,Dali::Actor > >();
1216           pv->reserve(capacity);
1217        } else {
1218           throw std::out_of_range("capacity");
1219        }
1220        return pv;
1221       }
1222 SWIGINTERN std::pair< unsigned int,Dali::Actor > std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index){
1223         if (index>=0 && index<(int)self->size())
1224           return (*self)[index];
1225         else
1226           throw std::out_of_range("index");
1227       }
1228 SWIGINTERN std::pair< unsigned int,Dali::Actor > const &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index){
1229         if (index>=0 && index<(int)self->size())
1230           return (*self)[index];
1231         else
1232           throw std::out_of_range("index");
1233       }
1234 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__setitem(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::pair< unsigned int,Dali::Actor > const &val){
1235         if (index>=0 && index<(int)self->size())
1236           (*self)[index] = val;
1237         else
1238           throw std::out_of_range("index");
1239       }
1240 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__AddRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,std::vector< std::pair< unsigned int,Dali::Actor > > const &values){
1241         self->insert(self->end(), values.begin(), values.end());
1242       }
1243 SWIGINTERN std::vector< std::pair< unsigned int,Dali::Actor > > *std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__GetRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,int count){
1244         if (index < 0)
1245           throw std::out_of_range("index");
1246         if (count < 0)
1247           throw std::out_of_range("count");
1248         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1249           throw std::invalid_argument("invalid range");
1250         return new std::vector< std::pair< unsigned int,Dali::Actor > >(self->begin()+index, self->begin()+index+count);
1251       }
1252 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Insert(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::pair< unsigned int,Dali::Actor > const &x){
1253         if (index>=0 && index<(int)self->size()+1)
1254           self->insert(self->begin()+index, x);
1255         else
1256           throw std::out_of_range("index");
1257       }
1258 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__InsertRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::vector< std::pair< unsigned int,Dali::Actor > > const &values){
1259         if (index>=0 && index<(int)self->size()+1)
1260           self->insert(self->begin()+index, values.begin(), values.end());
1261         else
1262           throw std::out_of_range("index");
1263       }
1264 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index){
1265         if (index>=0 && index<(int)self->size())
1266           self->erase(self->begin() + index);
1267         else
1268           throw std::out_of_range("index");
1269       }
1270 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,int count){
1271         if (index < 0)
1272           throw std::out_of_range("index");
1273         if (count < 0)
1274           throw std::out_of_range("count");
1275         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1276           throw std::invalid_argument("invalid range");
1277         self->erase(self->begin()+index, self->begin()+index+count);
1278       }
1279 SWIGINTERN std::vector< std::pair< unsigned int,Dali::Actor > > *std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Repeat(std::pair< unsigned int,Dali::Actor > const &value,int count){
1280         if (count < 0)
1281           throw std::out_of_range("count");
1282         return new std::vector< std::pair< unsigned int,Dali::Actor > >(count, value);
1283       }
1284 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(std::vector< std::pair< unsigned int,Dali::Actor > > *self){
1285         std::reverse(self->begin(), self->end());
1286       }
1287 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,int count){
1288         if (index < 0)
1289           throw std::out_of_range("index");
1290         if (count < 0)
1291           throw std::out_of_range("count");
1292         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1293           throw std::invalid_argument("invalid range");
1294         std::reverse(self->begin()+index, self->begin()+index+count);
1295       }
1296 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__SetRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::vector< std::pair< unsigned int,Dali::Actor > > const &values){
1297         if (index < 0)
1298           throw std::out_of_range("index");
1299         if (index+values.size() > self->size())
1300           throw std::out_of_range("index");
1301         std::copy(values.begin(), values.end(), self->begin()+index);
1302       }
1303 SWIGINTERN std::vector< Dali::Actor > *new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(int capacity){
1304         std::vector< Dali::Actor >* pv = 0;
1305         if (capacity >= 0) {
1306           pv = new std::vector< Dali::Actor >();
1307           pv->reserve(capacity);
1308        } else {
1309           throw std::out_of_range("capacity");
1310        }
1311        return pv;
1312       }
1313 SWIGINTERN Dali::Actor std_vector_Sl_Dali_Actor_Sg__getitemcopy(std::vector< Dali::Actor > *self,int index){
1314         if (index>=0 && index<(int)self->size())
1315           return (*self)[index];
1316         else
1317           throw std::out_of_range("index");
1318       }
1319 SWIGINTERN Dali::Actor const &std_vector_Sl_Dali_Actor_Sg__getitem(std::vector< Dali::Actor > *self,int index){
1320         if (index>=0 && index<(int)self->size())
1321           return (*self)[index];
1322         else
1323           throw std::out_of_range("index");
1324       }
1325 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__setitem(std::vector< Dali::Actor > *self,int index,Dali::Actor const &val){
1326         if (index>=0 && index<(int)self->size())
1327           (*self)[index] = val;
1328         else
1329           throw std::out_of_range("index");
1330       }
1331 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__AddRange(std::vector< Dali::Actor > *self,std::vector< Dali::Actor > const &values){
1332         self->insert(self->end(), values.begin(), values.end());
1333       }
1334 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__GetRange(std::vector< Dali::Actor > *self,int index,int count){
1335         if (index < 0)
1336           throw std::out_of_range("index");
1337         if (count < 0)
1338           throw std::out_of_range("count");
1339         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1340           throw std::invalid_argument("invalid range");
1341         return new std::vector< Dali::Actor >(self->begin()+index, self->begin()+index+count);
1342       }
1343 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Insert(std::vector< Dali::Actor > *self,int index,Dali::Actor const &x){
1344         if (index>=0 && index<(int)self->size()+1)
1345           self->insert(self->begin()+index, x);
1346         else
1347           throw std::out_of_range("index");
1348       }
1349 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__InsertRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1350         if (index>=0 && index<(int)self->size()+1)
1351           self->insert(self->begin()+index, values.begin(), values.end());
1352         else
1353           throw std::out_of_range("index");
1354       }
1355 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveAt(std::vector< Dali::Actor > *self,int index){
1356         if (index>=0 && index<(int)self->size())
1357           self->erase(self->begin() + index);
1358         else
1359           throw std::out_of_range("index");
1360       }
1361 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveRange(std::vector< Dali::Actor > *self,int index,int count){
1362         if (index < 0)
1363           throw std::out_of_range("index");
1364         if (count < 0)
1365           throw std::out_of_range("count");
1366         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1367           throw std::invalid_argument("invalid range");
1368         self->erase(self->begin()+index, self->begin()+index+count);
1369       }
1370 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__Repeat(Dali::Actor const &value,int count){
1371         if (count < 0)
1372           throw std::out_of_range("count");
1373         return new std::vector< Dali::Actor >(count, value);
1374       }
1375 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(std::vector< Dali::Actor > *self){
1376         std::reverse(self->begin(), self->end());
1377       }
1378 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(std::vector< Dali::Actor > *self,int index,int count){
1379         if (index < 0)
1380           throw std::out_of_range("index");
1381         if (count < 0)
1382           throw std::out_of_range("count");
1383         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1384           throw std::invalid_argument("invalid range");
1385         std::reverse(self->begin()+index, self->begin()+index+count);
1386       }
1387 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__SetRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1388         if (index < 0)
1389           throw std::out_of_range("index");
1390         if (index+values.size() > self->size())
1391           throw std::out_of_range("index");
1392         std::copy(values.begin(), values.end(), self->begin()+index);
1393       }
1394 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1395          return self->Empty();
1396       }
1397 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1398         return self->GetConnectionCount();
1399       }
1400 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *self,bool (*func)(Dali::Toolkit::AccessibilityManager &)){
1401           self->Connect( func );
1402       }
1403 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *self,bool (*func)(Dali::Toolkit::AccessibilityManager &)){
1404           self->Disconnect( func );
1405       }
1406 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *self,Dali::Toolkit::AccessibilityManager &arg){
1407           return self->Emit( arg );
1408       }
1409 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > const *self){
1410          return self->Empty();
1411       }
1412 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > const *self){
1413         return self->GetConnectionCount();
1414       }
1415 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *self,void (*func)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)){
1416         self->Connect( func );
1417       }
1418 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *self,void (*func)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)){
1419         self->Disconnect( func );
1420       }
1421 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *self,Dali::Actor arg1,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg2){
1422         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1423 /*@SWIG@*/ self->Emit( arg1, arg2 );
1424       }
1425 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1426          return self->Empty();
1427       }
1428 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1429         return self->GetConnectionCount();
1430       }
1431 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::Actor) > *self,void (*func)(Dali::Actor,Dali::Actor)){
1432         self->Connect( func );
1433       }
1434 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::Actor) > *self,void (*func)(Dali::Actor,Dali::Actor)){
1435         self->Disconnect( func );
1436       }
1437 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::Actor) > *self,Dali::Actor arg1,Dali::Actor arg2){
1438         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1439 /*@SWIG@*/ self->Emit( arg1, arg2 );
1440       }
1441 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool) > const *self){
1442          return self->Empty();
1443       }
1444 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool) > const *self){
1445         return self->GetConnectionCount();
1446       }
1447 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,bool) > *self,void (*func)(Dali::Actor,bool)){
1448         self->Connect( func );
1449       }
1450 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,bool) > *self,void (*func)(Dali::Actor,bool)){
1451         self->Disconnect( func );
1452       }
1453 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,bool) > *self,Dali::Actor arg1,bool arg2){
1454         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1455 /*@SWIG@*/ self->Emit( arg1, arg2 );
1456       }
1457 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > const *self){
1458          return self->Empty();
1459       }
1460 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > const *self){
1461         return self->GetConnectionCount();
1462       }
1463 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *self,void (*func)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)){
1464         self->Connect( func );
1465       }
1466 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *self,void (*func)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)){
1467         self->Disconnect( func );
1468       }
1469 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *self,Dali::Toolkit::StyleManager arg1,Dali::StyleChange::Type arg2){
1470         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1471 /*@SWIG@*/ self->Emit( arg1, arg2 );
1472       }
1473 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1474          return self->Empty();
1475       }
1476 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1477         return self->GetConnectionCount();
1478       }
1479 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Button) > *self,bool (*func)(Dali::Toolkit::Button)){
1480           self->Connect( func );
1481       }
1482 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Button) > *self,bool (*func)(Dali::Toolkit::Button)){
1483           self->Disconnect( func );
1484       }
1485 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Button) > *self,Dali::Toolkit::Button arg){
1486           return self->Emit( arg );
1487       }
1488 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1489          return self->Empty();
1490       }
1491 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1492         return self->GetConnectionCount();
1493       }
1494 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,void (*func)(Dali::Toolkit::GaussianBlurView)){
1495           self->Connect( func );
1496       }
1497 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,void (*func)(Dali::Toolkit::GaussianBlurView)){
1498           self->Disconnect( func );
1499       }
1500 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,Dali::Toolkit::GaussianBlurView arg){
1501           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1502 /*@SWIG@*/ self->Emit( arg );
1503       }
1504 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > const *self){
1505          return self->Empty();
1506       }
1507 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > const *self){
1508         return self->GetConnectionCount();
1509       }
1510 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *self,void (*func)(Dali::Toolkit::PageTurnView,unsigned int,bool)){
1511           return self->Connect( func );
1512       }
1513 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *self,void (*func)(Dali::Toolkit::PageTurnView,unsigned int,bool)){
1514           self->Disconnect( func );
1515       }
1516 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *self,Dali::Toolkit::PageTurnView arg1,unsigned int arg2,bool arg3){
1517           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1518 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1519       }
1520 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1521          return self->Empty();
1522       }
1523 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1524         return self->GetConnectionCount();
1525       }
1526 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,void (*func)(Dali::Toolkit::PageTurnView)){
1527           self->Connect( func );
1528       }
1529 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,void (*func)(Dali::Toolkit::PageTurnView)){
1530           self->Disconnect( func );
1531       }
1532 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,Dali::Toolkit::PageTurnView arg){
1533           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1534 /*@SWIG@*/ self->Emit( arg );
1535       }
1536 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > const *self){
1537          return self->Empty();
1538       }
1539 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > const *self){
1540         return self->GetConnectionCount();
1541       }
1542 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *self,void (*func)(Dali::Toolkit::ProgressBar,float,float)){
1543           return self->Connect( func );
1544       }
1545 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *self,void (*func)(Dali::Toolkit::ProgressBar,float,float)){
1546           self->Disconnect( func );
1547       }
1548 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *self,Dali::Toolkit::ProgressBar arg1,float arg2,float arg3){
1549           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1550 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1551       }
1552 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > const *self){
1553          return self->Empty();
1554       }
1555 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > const *self){
1556         return self->GetConnectionCount();
1557       }
1558 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *self,void (*func)(Dali::Toolkit::ScrollView::SnapEvent const &)){
1559           self->Connect( func );
1560       }
1561 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *self,void (*func)(Dali::Toolkit::ScrollView::SnapEvent const &)){
1562           self->Disconnect( func );
1563       }
1564 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *self,Dali::Toolkit::ScrollView::SnapEvent const &arg){
1565           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1566 /*@SWIG@*/ self->Emit( arg );
1567       }
1568 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1569          return self->Empty();
1570       }
1571 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1572         return self->GetConnectionCount();
1573       }
1574 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Vector2 const &) > *self,void (*func)(Dali::Vector2 const &)){
1575           self->Connect( func );
1576       }
1577 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Vector2 const &) > *self,void (*func)(Dali::Vector2 const &)){
1578           self->Disconnect( func );
1579       }
1580 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Vector2 const &) > *self,Dali::Vector2 const &arg){
1581           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1582 /*@SWIG@*/ self->Emit( arg );
1583       }
1584
1585
1586 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > const *self){
1587          return self->Empty();
1588       }
1589 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > const *self){
1590         return self->GetConnectionCount();
1591       }
1592 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *self,bool (*func)(Dali::Toolkit::Control,Dali::KeyEvent const &)){
1593         self->Connect( func );
1594       }
1595 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *self,bool (*func)(Dali::Toolkit::Control,Dali::KeyEvent const &)){
1596         self->Disconnect( func );
1597       }
1598 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *self,Dali::Toolkit::Control arg1,Dali::KeyEvent const &arg2){
1599         return self->Emit( arg1, arg2 );
1600       }
1601 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1602          return self->Empty();
1603       }
1604 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1605         return self->GetConnectionCount();
1606       }
1607 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::Control) > *self,void (*func)(Dali::Toolkit::Control)){
1608           self->Connect( func );
1609       }
1610 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::Control) > *self,void (*func)(Dali::Toolkit::Control)){
1611           self->Disconnect( func );
1612       }
1613 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::Control) > *self,Dali::Toolkit::Control arg){
1614           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1615 /*@SWIG@*/ self->Emit( arg );
1616       }
1617 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1618          return self->Empty();
1619       }
1620 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1621         return self->GetConnectionCount();
1622       }
1623 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::VideoView &) > *self,void (*func)(Dali::Toolkit::VideoView &)){
1624           self->Connect( func );
1625       }
1626 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::VideoView &) > *self,void (*func)(Dali::Toolkit::VideoView &)){
1627           self->Disconnect( func );
1628       }
1629 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::VideoView &) > *self,Dali::Toolkit::VideoView &arg){
1630           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1631 /*@SWIG@*/ self->Emit( arg );
1632       }
1633 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1634          return self->Empty();
1635       }
1636 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1637         return self->GetConnectionCount();
1638       }
1639 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Slider,float) > *self,bool (*func)(Dali::Toolkit::Slider,float)){
1640         self->Connect( func );
1641       }
1642 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Slider,float) > *self,bool (*func)(Dali::Toolkit::Slider,float)){
1643         self->Disconnect( func );
1644       }
1645 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Slider,float) > *self,Dali::Toolkit::Slider arg1,float arg2){
1646         return self->Emit( arg1, arg2 );
1647       }
1648 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1649          return self->Empty();
1650       }
1651 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1652         return self->GetConnectionCount();
1653       }
1654 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Slider,int) > *self,bool (*func)(Dali::Toolkit::Slider,int)){
1655         self->Connect( func );
1656       }
1657 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Slider,int) > *self,bool (*func)(Dali::Toolkit::Slider,int)){
1658         self->Disconnect( func );
1659       }
1660 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Slider,int) > *self,Dali::Toolkit::Slider arg1,int arg2){
1661         return self->Emit( arg1, arg2 );
1662       }
1663
1664 /* ---------------------------------------------------
1665  * C++ director class methods
1666  * --------------------------------------------------- */
1667
1668 #include "dali_wrap.h"
1669
1670 /*
1671  *  Widget director
1672  */
1673 SwigDirector_WidgetImpl::SwigDirector_WidgetImpl() : Dali::Internal::Adaptor::Widget(), Swig::Director() {
1674   swig_init_callbacks();
1675 }
1676
1677 SwigDirector_WidgetImpl::~SwigDirector_WidgetImpl() {
1678 }
1679
1680 void SwigDirector_WidgetImpl::OnCreate(std::string const &contentInfo, Dali::Window window) {
1681   char * jcontentInfo = 0 ;
1682   void * jwindow  ;
1683
1684   if (!swig_callbackOnCreate) {
1685     Dali::Internal::Adaptor::Widget::OnCreate(contentInfo,window);
1686     return;
1687   } else {
1688     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1689     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1690     swig_callbackOnCreate(jcontentInfo, jwindow);
1691   }
1692 }
1693
1694 void SwigDirector_WidgetImpl::OnTerminate(std::string const &contentInfo, Dali::Widget::Termination type) {
1695   char * jcontentInfo = 0 ;
1696   int jtype  ;
1697
1698   if (!swig_callbackOnTerminate) {
1699     Dali::Internal::Adaptor::Widget::OnTerminate(contentInfo,type);
1700     return;
1701   } else {
1702     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1703     jtype = (int)type;
1704     swig_callbackOnTerminate(jcontentInfo, jtype);
1705   }
1706 }
1707
1708 void SwigDirector_WidgetImpl::OnPause() {
1709   if (!swig_callbackOnPause) {
1710     Dali::Internal::Adaptor::Widget::OnPause();
1711     return;
1712   } else {
1713     swig_callbackOnPause();
1714   }
1715 }
1716
1717 void SwigDirector_WidgetImpl::OnResume() {
1718   if (!swig_callbackOnResume) {
1719     Dali::Internal::Adaptor::Widget::OnResume();
1720     return;
1721   } else {
1722     swig_callbackOnResume();
1723   }
1724 }
1725
1726 void SwigDirector_WidgetImpl::OnResize(Dali::Window window) {
1727   void * jwindow  ;
1728
1729   if (!swig_callbackOnResize) {
1730     Dali::Internal::Adaptor::Widget::OnResize(window);
1731     return;
1732   } else {
1733     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1734     swig_callbackOnResize(jwindow);
1735   }
1736 }
1737
1738 void SwigDirector_WidgetImpl::OnUpdate(std::string const &contentInfo, int force) {
1739   char * jcontentInfo = 0 ;
1740   int jforce  ;
1741
1742   if (!swig_callbackOnUpdate) {
1743     Dali::Internal::Adaptor::Widget::OnUpdate(contentInfo,force);
1744     return;
1745   } else {
1746     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1747     jforce = force;
1748     swig_callbackOnUpdate(jcontentInfo, jforce);
1749   }
1750 }
1751
1752 void SwigDirector_WidgetImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1753   void * jslotObserver = 0 ;
1754   void * jcallback = 0 ;
1755
1756   if (!swig_callbackSignalConnected) {
1757     Dali::Internal::Adaptor::Widget::SignalConnected(slotObserver,callback);
1758     return;
1759   } else {
1760     jslotObserver = (void *) slotObserver;
1761     jcallback = (void *) callback;
1762     swig_callbackSignalConnected(jslotObserver, jcallback);
1763   }
1764 }
1765
1766 void SwigDirector_WidgetImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1767   void * jslotObserver = 0 ;
1768   void * jcallback = 0 ;
1769
1770   if (!swig_callbackSignalDisconnected) {
1771     Dali::Internal::Adaptor::Widget::SignalDisconnected(slotObserver,callback);
1772     return;
1773   } else {
1774     jslotObserver = (void *) slotObserver;
1775     jcallback = (void *) callback;
1776     swig_callbackSignalDisconnected(jslotObserver, jcallback);
1777   }
1778 }
1779
1780 void SwigDirector_WidgetImpl::swig_connect_director(SWIG_Callback0_t callbackOnCreate, SWIG_Callback1_t callbackOnTerminate, SWIG_Callback2_t callbackOnPause, SWIG_Callback3_t callbackOnResume, SWIG_Callback4_t callbackOnResize, SWIG_Callback5_t callbackOnUpdate, SWIG_Callback6_t callbackSignalConnected, SWIG_Callback7_t callbackSignalDisconnected) {
1781
1782   swig_callbackOnCreate = callbackOnCreate;
1783   swig_callbackOnTerminate = callbackOnTerminate;
1784   swig_callbackOnPause = callbackOnPause;
1785   swig_callbackOnResume = callbackOnResume;
1786   swig_callbackOnResize = callbackOnResize;
1787   swig_callbackOnUpdate = callbackOnUpdate;
1788   swig_callbackSignalConnected = callbackSignalConnected;
1789   swig_callbackSignalDisconnected = callbackSignalDisconnected;
1790 }
1791
1792 void SwigDirector_WidgetImpl::swig_init_callbacks() {
1793   swig_callbackOnCreate = 0;
1794   swig_callbackOnTerminate = 0;
1795   swig_callbackOnPause = 0;
1796   swig_callbackOnResume = 0;
1797   swig_callbackOnResize = 0;
1798   swig_callbackOnUpdate = 0;
1799   swig_callbackSignalConnected = 0;
1800   swig_callbackSignalDisconnected = 0;
1801 }
1802
1803
1804 SwigDirector_ViewImpl::SwigDirector_ViewImpl(Dali::Toolkit::Internal::Control::ControlBehaviour behaviourFlags) : Dali::Toolkit::Internal::Control(behaviourFlags), Swig::Director() {
1805   swig_init_callbacks();
1806 }
1807
1808 SwigDirector_ViewImpl::~SwigDirector_ViewImpl() {
1809
1810 }
1811
1812
1813 void SwigDirector_ViewImpl::OnSceneConnection(int depth) {
1814   int jdepth  ;
1815
1816   if (!swig_callbackOnSceneConnection) {
1817     Dali::Toolkit::Internal::Control::OnSceneConnection(depth);
1818     return;
1819   } else {
1820     jdepth = depth;
1821     swig_callbackOnSceneConnection(jdepth);
1822   }
1823 }
1824
1825 void SwigDirector_ViewImpl::OnSceneDisconnection() {
1826   if (!swig_callbackOnSceneDisconnection) {
1827     Dali::Toolkit::Internal::Control::OnSceneDisconnection();
1828     return;
1829   } else {
1830     swig_callbackOnSceneDisconnection();
1831   }
1832 }
1833
1834 void SwigDirector_ViewImpl::OnChildAdd(Dali::Actor &child) {
1835   void * jchild = 0 ;
1836
1837   if (!swig_callbackOnChildAdd) {
1838     Dali::Toolkit::Internal::Control::OnChildAdd(child);
1839     return;
1840   } else {
1841     jchild = (Dali::Actor *) &child;
1842     swig_callbackOnChildAdd(jchild);
1843   }
1844 }
1845
1846 void SwigDirector_ViewImpl::OnChildRemove(Dali::Actor &child) {
1847   void * jchild = 0 ;
1848
1849   if (!swig_callbackOnChildRemove) {
1850     Dali::Toolkit::Internal::Control::OnChildRemove(child);
1851     return;
1852   } else {
1853     jchild = (Dali::Actor *) &child;
1854     swig_callbackOnChildRemove(jchild);
1855   }
1856 }
1857
1858 void SwigDirector_ViewImpl::OnPropertySet(Dali::Property::Index index, Dali::Property::Value propertyValue) {
1859   int jindex  ;
1860   void * jpropertyValue  ;
1861
1862   if (!swig_callbackOnPropertySet) {
1863     Dali::Toolkit::Internal::Control::OnPropertySet(index,propertyValue);
1864     return;
1865   } else {
1866     jindex = index;
1867     jpropertyValue = (void *)new Dali::Property::Value((const Dali::Property::Value &)propertyValue);
1868     swig_callbackOnPropertySet(jindex, jpropertyValue);
1869   }
1870 }
1871
1872 void SwigDirector_ViewImpl::OnSizeSet(Dali::Vector3 const &targetSize) {
1873   void * jtargetSize = 0 ;
1874
1875   if (!swig_callbackOnSizeSet) {
1876     Dali::Toolkit::Internal::Control::OnSizeSet(targetSize);
1877     return;
1878   } else {
1879     jtargetSize = (Dali::Vector3 *) &targetSize;
1880     swig_callbackOnSizeSet(jtargetSize);
1881   }
1882 }
1883
1884 void SwigDirector_ViewImpl::OnSizeAnimation(Dali::Animation &animation, Dali::Vector3 const &targetSize) {
1885   void * janimation = 0 ;
1886   void * jtargetSize = 0 ;
1887
1888   if (!swig_callbackOnSizeAnimation) {
1889     Dali::Toolkit::Internal::Control::OnSizeAnimation(animation,targetSize);
1890     return;
1891   } else {
1892     janimation = (Dali::Animation *) &animation;
1893     jtargetSize = (Dali::Vector3 *) &targetSize;
1894     swig_callbackOnSizeAnimation(janimation, jtargetSize);
1895   }
1896 }
1897
1898 bool SwigDirector_ViewImpl::OnHoverEvent(Dali::HoverEvent const &event) {
1899   bool c_result = SwigValueInit< bool >() ;
1900   unsigned int jresult = 0 ;
1901   void * jarg0 = 0 ;
1902
1903   if (!swig_callbackOnHoverEvent) {
1904     return Dali::Toolkit::Internal::Control::OnHoverEvent(event);
1905   } else {
1906     jarg0 = (Dali::HoverEvent *) &event;
1907     jresult = (unsigned int) swig_callbackOnHoverEvent(jarg0);
1908     c_result = jresult ? true : false;
1909   }
1910   return c_result;
1911 }
1912
1913 bool SwigDirector_ViewImpl::OnKeyEvent(Dali::KeyEvent const &event) {
1914   bool c_result = SwigValueInit< bool >() ;
1915   unsigned int jresult = 0 ;
1916   void * jarg0 = 0 ;
1917
1918   if (!swig_callbackOnKeyEvent) {
1919     return Dali::Toolkit::Internal::Control::OnKeyEvent(event);
1920   } else {
1921     jarg0 = (Dali::KeyEvent *) &event;
1922     jresult = (unsigned int) swig_callbackOnKeyEvent(jarg0);
1923     c_result = jresult ? true : false;
1924   }
1925   return c_result;
1926 }
1927
1928 bool SwigDirector_ViewImpl::OnWheelEvent(Dali::WheelEvent const &event) {
1929   bool c_result = SwigValueInit< bool >() ;
1930   unsigned int jresult = 0 ;
1931   void * jarg0 = 0 ;
1932
1933   if (!swig_callbackOnWheelEvent) {
1934     return Dali::Toolkit::Internal::Control::OnWheelEvent(event);
1935   } else {
1936     jarg0 = (Dali::WheelEvent *) &event;
1937     jresult = (unsigned int) swig_callbackOnWheelEvent(jarg0);
1938     c_result = jresult ? true : false;
1939   }
1940   return c_result;
1941 }
1942
1943 void SwigDirector_ViewImpl::OnRelayout(Dali::Vector2 const &size, Dali::RelayoutContainer &container) {
1944   void * jsize = 0 ;
1945   void * jcontainer = 0 ;
1946
1947   if (!swig_callbackOnRelayout) {
1948     Dali::Toolkit::Internal::Control::OnRelayout(size,container);
1949     return;
1950   } else {
1951     jsize = (Dali::Vector2 *) &size;
1952     jcontainer = (Dali::RelayoutContainer *) &container;
1953     swig_callbackOnRelayout(jsize, jcontainer);
1954   }
1955 }
1956
1957 void SwigDirector_ViewImpl::OnSetResizePolicy(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension) {
1958   int jpolicy  ;
1959   int jdimension  ;
1960
1961   if (!swig_callbackOnSetResizePolicy) {
1962     Dali::Toolkit::Internal::Control::OnSetResizePolicy(policy,dimension);
1963     return;
1964   } else {
1965     jpolicy = (int)policy;
1966     jdimension = (int)dimension;
1967     swig_callbackOnSetResizePolicy(jpolicy, jdimension);
1968   }
1969 }
1970
1971 Dali::Vector3 SwigDirector_ViewImpl::GetNaturalSize() {
1972   Dali::Vector3 c_result ;
1973   void * jresult = 0 ;
1974
1975   if (!swig_callbackGetNaturalSize) {
1976     return Dali::Toolkit::Internal::Control::GetNaturalSize();
1977   } else {
1978     jresult = (void *) swig_callbackGetNaturalSize();
1979     if (!jresult) {
1980       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Vector3", 0);
1981       return c_result;
1982     }
1983     c_result = *(Dali::Vector3 *)jresult;
1984   }
1985   return c_result;
1986 }
1987
1988 float SwigDirector_ViewImpl::CalculateChildSize(Dali::Actor const &child, Dali::Dimension::Type dimension) {
1989   float c_result = SwigValueInit< float >() ;
1990   float jresult = 0 ;
1991   void * jchild = 0 ;
1992   int jdimension  ;
1993
1994   if (!swig_callbackCalculateChildSize) {
1995     return Dali::Toolkit::Internal::Control::CalculateChildSize(child,dimension);
1996   } else {
1997     jchild = (Dali::Actor *) &child;
1998     jdimension = (int)dimension;
1999     jresult = (float) swig_callbackCalculateChildSize(jchild, jdimension);
2000     c_result = (float)jresult;
2001   }
2002   return c_result;
2003 }
2004
2005 float SwigDirector_ViewImpl::GetHeightForWidth(float width) {
2006   float c_result = SwigValueInit< float >() ;
2007   float jresult = 0 ;
2008   float jwidth  ;
2009
2010   if (!swig_callbackGetHeightForWidth) {
2011     return Dali::Toolkit::Internal::Control::GetHeightForWidth(width);
2012   } else {
2013     jwidth = width;
2014     jresult = (float) swig_callbackGetHeightForWidth(jwidth);
2015     c_result = (float)jresult;
2016   }
2017   return c_result;
2018 }
2019
2020 float SwigDirector_ViewImpl::GetWidthForHeight(float height) {
2021   float c_result = SwigValueInit< float >() ;
2022   float jresult = 0 ;
2023   float jheight  ;
2024
2025   if (!swig_callbackGetWidthForHeight) {
2026     return Dali::Toolkit::Internal::Control::GetWidthForHeight(height);
2027   } else {
2028     jheight = height;
2029     jresult = (float) swig_callbackGetWidthForHeight(jheight);
2030     c_result = (float)jresult;
2031   }
2032   return c_result;
2033 }
2034
2035 bool SwigDirector_ViewImpl::RelayoutDependentOnChildren(Dali::Dimension::Type dimension) {
2036   bool c_result = SwigValueInit< bool >() ;
2037   unsigned int jresult = 0 ;
2038   int jdimension  ;
2039
2040   if (!swig_callbackRelayoutDependentOnChildren__SWIG_0) {
2041     return Dali::Toolkit::Internal::Control::RelayoutDependentOnChildren(dimension);
2042   } else {
2043     jdimension = (int)dimension;
2044     jresult = (unsigned int) swig_callbackRelayoutDependentOnChildren__SWIG_0(jdimension);
2045     c_result = jresult ? true : false;
2046   }
2047   return c_result;
2048 }
2049
2050 void SwigDirector_ViewImpl::OnCalculateRelayoutSize(Dali::Dimension::Type dimension) {
2051   int jdimension  ;
2052
2053   if (!swig_callbackOnCalculateRelayoutSize) {
2054     Dali::Toolkit::Internal::Control::OnCalculateRelayoutSize(dimension);
2055     return;
2056   } else {
2057     jdimension = (int)dimension;
2058     swig_callbackOnCalculateRelayoutSize(jdimension);
2059   }
2060 }
2061
2062 void SwigDirector_ViewImpl::OnLayoutNegotiated(float size, Dali::Dimension::Type dimension) {
2063   float jsize  ;
2064   int jdimension  ;
2065
2066   if (!swig_callbackOnLayoutNegotiated) {
2067     Dali::Toolkit::Internal::Control::OnLayoutNegotiated(size,dimension);
2068     return;
2069   } else {
2070     jsize = size;
2071     jdimension = (int)dimension;
2072     swig_callbackOnLayoutNegotiated(jsize, jdimension);
2073   }
2074 }
2075
2076 Dali::CustomActorImpl::Extension *SwigDirector_ViewImpl::GetExtension() {
2077   return Dali::CustomActorImpl::GetExtension();
2078 }
2079
2080 void SwigDirector_ViewImpl::OnInitialize() {
2081   if (!swig_callbackOnInitialize) {
2082     Dali::Toolkit::Internal::Control::OnInitialize();
2083     return;
2084   } else {
2085     swig_callbackOnInitialize();
2086   }
2087 }
2088
2089 void SwigDirector_ViewImpl::OnStyleChange(Dali::Toolkit::StyleManager styleManager, Dali::StyleChange::Type change) {
2090   void * jstyleManager  ;
2091   int jchange  ;
2092
2093   if (!swig_callbackOnStyleChange) {
2094     Dali::Toolkit::Internal::Control::OnStyleChange(styleManager,change);
2095     return;
2096   } else {
2097     jstyleManager = (void *)new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)styleManager);
2098     jchange = (int)change;
2099     swig_callbackOnStyleChange(jstyleManager, jchange);
2100   }
2101 }
2102
2103 bool SwigDirector_ViewImpl::OnAccessibilityActivated() {
2104   bool c_result = SwigValueInit< bool >() ;
2105   unsigned int jresult = 0 ;
2106
2107   if (!swig_callbackOnAccessibilityActivated) {
2108     return Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
2109   } else {
2110     jresult = (unsigned int) swig_callbackOnAccessibilityActivated();
2111     c_result = jresult ? true : false;
2112   }
2113   return c_result;
2114 }
2115
2116 bool SwigDirector_ViewImpl::OnAccessibilityPan(Dali::PanGesture gesture) {
2117   bool c_result = SwigValueInit< bool >() ;
2118   unsigned int jresult = 0 ;
2119   void * jgesture  ;
2120
2121   if (!swig_callbackOnAccessibilityPan) {
2122     return Dali::Toolkit::Internal::Control::OnAccessibilityPan(gesture);
2123   } else {
2124     jgesture = (void *)new Dali::PanGesture((const Dali::PanGesture &)gesture);
2125     jresult = (unsigned int) swig_callbackOnAccessibilityPan(jgesture);
2126     c_result = jresult ? true : false;
2127   }
2128   return c_result;
2129 }
2130
2131 bool SwigDirector_ViewImpl::OnAccessibilityValueChange(bool isIncrease) {
2132   bool c_result = SwigValueInit< bool >() ;
2133   unsigned int jresult = 0 ;
2134   unsigned int jisIncrease  ;
2135
2136   if (!swig_callbackOnAccessibilityValueChange) {
2137     return Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(isIncrease);
2138   } else {
2139     jisIncrease = isIncrease;
2140     jresult = (unsigned int) swig_callbackOnAccessibilityValueChange(jisIncrease);
2141     c_result = jresult ? true : false;
2142   }
2143   return c_result;
2144 }
2145
2146 bool SwigDirector_ViewImpl::OnAccessibilityZoom() {
2147   bool c_result = SwigValueInit< bool >() ;
2148   unsigned int jresult = 0 ;
2149
2150   if (!swig_callbackOnAccessibilityZoom) {
2151     return Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
2152   } else {
2153     jresult = (unsigned int) swig_callbackOnAccessibilityZoom();
2154     c_result = jresult ? true : false;
2155   }
2156   return c_result;
2157 }
2158
2159 void SwigDirector_ViewImpl::OnKeyInputFocusGained() {
2160   if (!swig_callbackOnKeyInputFocusGained) {
2161     Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
2162     return;
2163   } else {
2164     swig_callbackOnKeyInputFocusGained();
2165   }
2166 }
2167
2168 void SwigDirector_ViewImpl::OnKeyInputFocusLost() {
2169   if (!swig_callbackOnKeyInputFocusLost) {
2170     Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
2171     return;
2172   } else {
2173     swig_callbackOnKeyInputFocusLost();
2174   }
2175 }
2176
2177 Dali::Actor SwigDirector_ViewImpl::GetNextKeyboardFocusableActor(Dali::Actor currentFocusedActor, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled) {
2178   Dali::Actor c_result ;
2179   void * jresult = 0 ;
2180   void * jcurrentFocusedActor  ;
2181   int jdirection  ;
2182   unsigned int jloopEnabled  ;
2183
2184   if (!swig_callbackGetNextKeyboardFocusableActor) {
2185     return Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(currentFocusedActor,direction,loopEnabled);
2186   } else {
2187     jcurrentFocusedActor = (void *)new Dali::Actor((const Dali::Actor &)currentFocusedActor);
2188     jdirection = (int)direction;
2189     jloopEnabled = loopEnabled;
2190     jresult = (void *) swig_callbackGetNextKeyboardFocusableActor(jcurrentFocusedActor, jdirection, jloopEnabled);
2191     if (!jresult) {
2192       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2193       return c_result;
2194     }
2195     c_result = *(Dali::Actor *)jresult;
2196   }
2197   return c_result;
2198 }
2199
2200 void SwigDirector_ViewImpl::OnKeyboardFocusChangeCommitted(Dali::Actor commitedFocusableActor) {
2201   void * jcommitedFocusableActor  ;
2202
2203   if (!swig_callbackOnKeyboardFocusChangeCommitted) {
2204     Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(commitedFocusableActor);
2205     return;
2206   } else {
2207     jcommitedFocusableActor = (void *)new Dali::Actor((const Dali::Actor &)commitedFocusableActor);
2208     swig_callbackOnKeyboardFocusChangeCommitted(jcommitedFocusableActor);
2209   }
2210 }
2211
2212 bool SwigDirector_ViewImpl::OnKeyboardEnter() {
2213   bool c_result = SwigValueInit< bool >() ;
2214   unsigned int jresult = 0 ;
2215
2216   if (!swig_callbackOnKeyboardEnter) {
2217     return Dali::Toolkit::Internal::Control::OnKeyboardEnter();
2218   } else {
2219     jresult = (unsigned int) swig_callbackOnKeyboardEnter();
2220     c_result = jresult ? true : false;
2221   }
2222   return c_result;
2223 }
2224
2225 void SwigDirector_ViewImpl::OnPinch(Dali::PinchGesture const &pinch) {
2226   void * jpinch = 0 ;
2227
2228   if (!swig_callbackOnPinch) {
2229     Dali::Toolkit::Internal::Control::OnPinch(pinch);
2230     return;
2231   } else {
2232     jpinch = (Dali::PinchGesture *) &pinch;
2233     swig_callbackOnPinch(jpinch);
2234   }
2235 }
2236
2237 void SwigDirector_ViewImpl::OnPan(Dali::PanGesture const &pan) {
2238   void * jpan = 0 ;
2239
2240   if (!swig_callbackOnPan) {
2241     Dali::Toolkit::Internal::Control::OnPan(pan);
2242     return;
2243   } else {
2244     jpan = (Dali::PanGesture *) &pan;
2245     swig_callbackOnPan(jpan);
2246   }
2247 }
2248
2249 void SwigDirector_ViewImpl::OnTap(Dali::TapGesture const &tap) {
2250   void * jtap = 0 ;
2251
2252   if (!swig_callbackOnTap) {
2253     Dali::Toolkit::Internal::Control::OnTap(tap);
2254     return;
2255   } else {
2256     jtap = (Dali::TapGesture *) &tap;
2257     swig_callbackOnTap(jtap);
2258   }
2259 }
2260
2261 void SwigDirector_ViewImpl::OnLongPress(Dali::LongPressGesture const &longPress) {
2262   void * jlongPress = 0 ;
2263
2264   if (!swig_callbackOnLongPress) {
2265     Dali::Toolkit::Internal::Control::OnLongPress(longPress);
2266     return;
2267   } else {
2268     jlongPress = (Dali::LongPressGesture *) &longPress;
2269     swig_callbackOnLongPress(jlongPress);
2270   }
2271 }
2272
2273 void SwigDirector_ViewImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2274   void * jslotObserver = 0 ;
2275   void * jcallback = 0 ;
2276
2277   if (!swig_callbackSignalConnected) {
2278     Dali::Toolkit::Internal::Control::SignalConnected(slotObserver,callback);
2279     return;
2280   } else {
2281     jslotObserver = (void *) slotObserver;
2282     jcallback = (void *) callback;
2283     swig_callbackSignalConnected(jslotObserver, jcallback);
2284   }
2285 }
2286
2287 void SwigDirector_ViewImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2288   void * jslotObserver = 0 ;
2289   void * jcallback = 0 ;
2290
2291   if (!swig_callbackSignalDisconnected) {
2292     Dali::Toolkit::Internal::Control::SignalDisconnected(slotObserver,callback);
2293     return;
2294   } else {
2295     jslotObserver = (void *) slotObserver;
2296     jcallback = (void *) callback;
2297     swig_callbackSignalDisconnected(jslotObserver, jcallback);
2298   }
2299 }
2300
2301 Dali::Toolkit::Internal::Control::Extension *SwigDirector_ViewImpl::GetControlExtension() {
2302   return Dali::Toolkit::Internal::Control::GetControlExtension();
2303 }
2304
2305 void SwigDirector_ViewImpl::swig_connect_director(SWIG_Callback0_t callbackOnSceneConnection, SWIG_Callback1_t callbackOnSceneDisconnection, SWIG_Callback2_t callbackOnChildAdd, SWIG_Callback3_t callbackOnChildRemove, SWIG_Callback4_t callbackOnPropertySet, SWIG_Callback5_t callbackOnSizeSet, SWIG_Callback6_t callbackOnSizeAnimation, SWIG_Callback8_t callbackOnHoverEvent, SWIG_Callback9_t callbackOnKeyEvent, SWIG_Callback10_t callbackOnWheelEvent, SWIG_Callback11_t callbackOnRelayout, SWIG_Callback12_t callbackOnSetResizePolicy, SWIG_Callback13_t callbackGetNaturalSize, SWIG_Callback14_t callbackCalculateChildSize, SWIG_Callback15_t callbackGetHeightForWidth, SWIG_Callback16_t callbackGetWidthForHeight, SWIG_Callback17_t callbackRelayoutDependentOnChildren__SWIG_0, SWIG_Callback18_t callbackRelayoutDependentOnChildren__SWIG_1, SWIG_Callback19_t callbackOnCalculateRelayoutSize, SWIG_Callback20_t callbackOnLayoutNegotiated, SWIG_Callback21_t callbackOnInitialize, SWIG_Callback24_t callbackOnStyleChange, SWIG_Callback25_t callbackOnAccessibilityActivated, SWIG_Callback26_t callbackOnAccessibilityPan, SWIG_Callback28_t callbackOnAccessibilityValueChange, SWIG_Callback29_t callbackOnAccessibilityZoom, SWIG_Callback30_t callbackOnKeyInputFocusGained, SWIG_Callback31_t callbackOnKeyInputFocusLost, SWIG_Callback32_t callbackGetNextKeyboardFocusableActor, SWIG_Callback33_t callbackOnKeyboardFocusChangeCommitted, SWIG_Callback34_t callbackOnKeyboardEnter, SWIG_Callback35_t callbackOnPinch, SWIG_Callback36_t callbackOnPan, SWIG_Callback37_t callbackOnTap, SWIG_Callback38_t callbackOnLongPress, SWIG_Callback39_t callbackSignalConnected, SWIG_Callback40_t callbackSignalDisconnected) {
2306   swig_callbackOnSceneConnection = callbackOnSceneConnection;
2307   swig_callbackOnSceneDisconnection = callbackOnSceneDisconnection;
2308   swig_callbackOnChildAdd = callbackOnChildAdd;
2309   swig_callbackOnChildRemove = callbackOnChildRemove;
2310   swig_callbackOnPropertySet = callbackOnPropertySet;
2311   swig_callbackOnSizeSet = callbackOnSizeSet;
2312   swig_callbackOnSizeAnimation = callbackOnSizeAnimation;
2313   swig_callbackOnHoverEvent = callbackOnHoverEvent;
2314   swig_callbackOnKeyEvent = callbackOnKeyEvent;
2315   swig_callbackOnWheelEvent = callbackOnWheelEvent;
2316   swig_callbackOnRelayout = callbackOnRelayout;
2317   swig_callbackOnSetResizePolicy = callbackOnSetResizePolicy;
2318   swig_callbackGetNaturalSize = callbackGetNaturalSize;
2319   swig_callbackCalculateChildSize = callbackCalculateChildSize;
2320   swig_callbackGetHeightForWidth = callbackGetHeightForWidth;
2321   swig_callbackGetWidthForHeight = callbackGetWidthForHeight;
2322   swig_callbackRelayoutDependentOnChildren__SWIG_0 = callbackRelayoutDependentOnChildren__SWIG_0;
2323   swig_callbackRelayoutDependentOnChildren__SWIG_1 = callbackRelayoutDependentOnChildren__SWIG_1;
2324   swig_callbackOnCalculateRelayoutSize = callbackOnCalculateRelayoutSize;
2325   swig_callbackOnLayoutNegotiated = callbackOnLayoutNegotiated;
2326   swig_callbackOnInitialize = callbackOnInitialize;
2327   swig_callbackOnStyleChange = callbackOnStyleChange;
2328   swig_callbackOnAccessibilityActivated = callbackOnAccessibilityActivated;
2329   swig_callbackOnAccessibilityPan = callbackOnAccessibilityPan;
2330   swig_callbackOnAccessibilityValueChange = callbackOnAccessibilityValueChange;
2331   swig_callbackOnAccessibilityZoom = callbackOnAccessibilityZoom;
2332   swig_callbackOnKeyInputFocusGained = callbackOnKeyInputFocusGained;
2333   swig_callbackOnKeyInputFocusLost = callbackOnKeyInputFocusLost;
2334   swig_callbackGetNextKeyboardFocusableActor = callbackGetNextKeyboardFocusableActor;
2335   swig_callbackOnKeyboardFocusChangeCommitted = callbackOnKeyboardFocusChangeCommitted;
2336   swig_callbackOnKeyboardEnter = callbackOnKeyboardEnter;
2337   swig_callbackOnPinch = callbackOnPinch;
2338   swig_callbackOnPan = callbackOnPan;
2339   swig_callbackOnTap = callbackOnTap;
2340   swig_callbackOnLongPress = callbackOnLongPress;
2341   swig_callbackSignalConnected = callbackSignalConnected;
2342   swig_callbackSignalDisconnected = callbackSignalDisconnected;
2343 }
2344
2345 void SwigDirector_ViewImpl::swig_init_callbacks() {
2346   swig_callbackOnSceneConnection = 0;
2347   swig_callbackOnSceneDisconnection = 0;
2348   swig_callbackOnChildAdd = 0;
2349   swig_callbackOnChildRemove = 0;
2350   swig_callbackOnPropertySet = 0;
2351   swig_callbackOnSizeSet = 0;
2352   swig_callbackOnSizeAnimation = 0;
2353   swig_callbackOnHoverEvent = 0;
2354   swig_callbackOnKeyEvent = 0;
2355   swig_callbackOnWheelEvent = 0;
2356   swig_callbackOnRelayout = 0;
2357   swig_callbackOnSetResizePolicy = 0;
2358   swig_callbackGetNaturalSize = 0;
2359   swig_callbackCalculateChildSize = 0;
2360   swig_callbackGetHeightForWidth = 0;
2361   swig_callbackGetWidthForHeight = 0;
2362   swig_callbackRelayoutDependentOnChildren__SWIG_0 = 0;
2363   swig_callbackRelayoutDependentOnChildren__SWIG_1 = 0;
2364   swig_callbackOnCalculateRelayoutSize = 0;
2365   swig_callbackOnLayoutNegotiated = 0;
2366   swig_callbackOnInitialize = 0;
2367   swig_callbackOnStyleChange = 0;
2368   swig_callbackOnAccessibilityActivated = 0;
2369   swig_callbackOnAccessibilityPan = 0;
2370   swig_callbackOnAccessibilityValueChange = 0;
2371   swig_callbackOnAccessibilityZoom = 0;
2372   swig_callbackOnKeyInputFocusGained = 0;
2373   swig_callbackOnKeyInputFocusLost = 0;
2374   swig_callbackGetNextKeyboardFocusableActor = 0;
2375   swig_callbackOnKeyboardFocusChangeCommitted = 0;
2376   swig_callbackOnKeyboardEnter = 0;
2377   swig_callbackOnPinch = 0;
2378   swig_callbackOnPan = 0;
2379   swig_callbackOnTap = 0;
2380   swig_callbackOnLongPress = 0;
2381   swig_callbackSignalConnected = 0;
2382   swig_callbackSignalDisconnected = 0;
2383 }
2384
2385 SwigDirector_ItemFactory::SwigDirector_ItemFactory() : Dali::Toolkit::ItemFactory(), Swig::Director() {
2386   swig_init_callbacks();
2387 }
2388
2389 SwigDirector_ItemFactory::~SwigDirector_ItemFactory() {
2390
2391 }
2392
2393
2394 unsigned int SwigDirector_ItemFactory::GetNumberOfItems() {
2395   unsigned int c_result = SwigValueInit< unsigned int >() ;
2396   unsigned int jresult = 0 ;
2397
2398   if (!swig_callbackGetNumberOfItems) {
2399     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::GetNumberOfItems");
2400   } else {
2401     jresult = (unsigned int) swig_callbackGetNumberOfItems();
2402     c_result = (unsigned int)jresult;
2403   }
2404   return c_result;
2405 }
2406
2407 Dali::Actor SwigDirector_ItemFactory::NewItem(unsigned int itemId) {
2408   Dali::Actor c_result ;
2409   void * jresult = 0 ;
2410   unsigned int jitemId  ;
2411
2412   if (!swig_callbackNewItem) {
2413     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::NewItem");
2414   } else {
2415     jitemId = itemId;
2416     jresult = (void *) swig_callbackNewItem(jitemId);
2417     if (!jresult) {
2418       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2419       return c_result;
2420     }
2421     c_result = *(Dali::Actor *)jresult;
2422   }
2423   return c_result;
2424 }
2425
2426 void SwigDirector_ItemFactory::ItemReleased(unsigned int itemId, Dali::Actor actor) {
2427   unsigned int jitemId  ;
2428   void * jactor  ;
2429
2430   if (!swig_callbackItemReleased) {
2431     Dali::Toolkit::ItemFactory::ItemReleased(itemId,actor);
2432     return;
2433   } else {
2434     jitemId = itemId;
2435     jactor = (void *)new Dali::Actor((const Dali::Actor &)actor);
2436     swig_callbackItemReleased(jitemId, jactor);
2437   }
2438 }
2439
2440 Dali::Toolkit::ItemFactory::Extension *SwigDirector_ItemFactory::GetExtension() {
2441   return Dali::Toolkit::ItemFactory::GetExtension();
2442 }
2443
2444 void SwigDirector_ItemFactory::swig_connect_director(SWIG_Callback0_t callbackGetNumberOfItems, SWIG_Callback1_t callbackNewItem, SWIG_Callback2_t callbackItemReleased) {
2445   swig_callbackGetNumberOfItems = callbackGetNumberOfItems;
2446   swig_callbackNewItem = callbackNewItem;
2447   swig_callbackItemReleased = callbackItemReleased;
2448 }
2449
2450 void SwigDirector_ItemFactory::swig_init_callbacks() {
2451   swig_callbackGetNumberOfItems = 0;
2452   swig_callbackNewItem = 0;
2453   swig_callbackItemReleased = 0;
2454 }
2455
2456 SwigDirector_CustomAlgorithmInterface::SwigDirector_CustomAlgorithmInterface() : Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface(), Swig::Director() {
2457   swig_init_callbacks();
2458 }
2459
2460 SwigDirector_CustomAlgorithmInterface::~SwigDirector_CustomAlgorithmInterface() {
2461
2462 }
2463
2464
2465 Dali::Actor SwigDirector_CustomAlgorithmInterface::GetNextFocusableActor(Dali::Actor current, Dali::Actor proposed, Dali::Toolkit::Control::KeyboardFocus::Direction direction) {
2466   Dali::Actor c_result ;
2467   void * jresult = 0 ;
2468   void * jcurrent  ;
2469   void * jproposed  ;
2470   int jdirection  ;
2471
2472   if (!swig_callbackGetNextFocusableActor) {
2473     throw Swig::DirectorPureVirtualException("Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface::GetNextFocusableActor");
2474   } else {
2475     jcurrent = (void *)new Dali::Actor((const Dali::Actor &)current);
2476     jproposed = (void *)new Dali::Actor((const Dali::Actor &)proposed);
2477     jdirection = (int)direction;
2478     jresult = (void *) swig_callbackGetNextFocusableActor(jcurrent, jproposed, jdirection);
2479     if (!jresult) {
2480       DALI_LOG_ERROR("[ERROR][%s line:%d] Unexpected null return for type Dali::Actor! Next focus will be NULL, please be cautious to handle the keyboard foucs! ", __FILE__, __LINE__);
2481       return c_result;
2482     }
2483     c_result = *(Dali::Actor *)jresult;
2484   }
2485   return c_result;
2486 }
2487
2488 void SwigDirector_CustomAlgorithmInterface::swig_connect_director(SWIG_Callback0_t callbackGetNextFocusableActor) {
2489   swig_callbackGetNextFocusableActor = callbackGetNextFocusableActor;
2490 }
2491
2492 void SwigDirector_CustomAlgorithmInterface::swig_init_callbacks() {
2493   swig_callbackGetNextFocusableActor = 0;
2494 }
2495
2496 SwigDirector_FrameCallbackInterface::SwigDirector_FrameCallbackInterface() : Dali::FrameCallbackInterface(), Swig::Director() {
2497   swig_callbackOnUpdate = 0;
2498 }
2499
2500 SwigDirector_FrameCallbackInterface::~SwigDirector_FrameCallbackInterface() {
2501
2502 }
2503
2504 void SwigDirector_FrameCallbackInterface::swig_connect_director(SWIG_Callback0_t callbackUpdate) {
2505   swig_callbackOnUpdate = callbackUpdate;
2506 }
2507
2508
2509 void SwigDirector_FrameCallbackInterface::Update(Dali::UpdateProxy& updateProxy, float elapsedSeconds) {
2510   void * jcurrent  ;
2511
2512   if (!swig_callbackOnUpdate) {
2513     throw Swig::DirectorPureVirtualException("Dali::FrameCallbackInterface::Update");
2514   } else {
2515     Dali::UpdateProxy* proxy = &updateProxy;
2516     jcurrent = (void *)proxy;
2517     swig_callbackOnUpdate(jcurrent, elapsedSeconds);
2518     if (!jcurrent) {
2519       DALI_LOG_ERROR("[ERROR][%s line:%d] Unexpected null return for type Dali::UpdateProxy! ", __FILE__, __LINE__);
2520       return;
2521     }
2522   }
2523   return;
2524 }
2525
2526
2527 #ifdef __cplusplus
2528 extern "C" {
2529 #endif
2530
2531 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_floatp() {
2532   void * jresult ;
2533   floatp *result = 0 ;
2534
2535   {
2536     try {
2537       result = (floatp *)new_floatp();
2538     } CALL_CATCH_EXCEPTION(0);
2539   }
2540   jresult = (void *)result;
2541   return jresult;
2542 }
2543
2544
2545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_floatp(void * jarg1) {
2546   floatp *arg1 = (floatp *) 0 ;
2547
2548   arg1 = (floatp *)jarg1;
2549   {
2550     try {
2551       delete_floatp(arg1);
2552     } CALL_CATCH_EXCEPTION();
2553   }
2554
2555 }
2556
2557
2558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_floatp_assign(void * jarg1, float jarg2) {
2559   floatp *arg1 = (floatp *) 0 ;
2560   float arg2 ;
2561
2562   arg1 = (floatp *)jarg1;
2563   arg2 = (float)jarg2;
2564   {
2565     try {
2566       floatp_assign(arg1,arg2);
2567     } CALL_CATCH_EXCEPTION();
2568   }
2569
2570 }
2571
2572
2573 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_floatp_value(void * jarg1) {
2574   float jresult ;
2575   floatp *arg1 = (floatp *) 0 ;
2576   float result;
2577
2578   arg1 = (floatp *)jarg1;
2579   {
2580     try {
2581       result = (float)floatp_value(arg1);
2582     } CALL_CATCH_EXCEPTION(0);
2583   }
2584   jresult = result;
2585   return jresult;
2586 }
2587
2588
2589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_cast(void * jarg1) {
2590   void * jresult ;
2591   floatp *arg1 = (floatp *) 0 ;
2592   float *result = 0 ;
2593
2594   arg1 = (floatp *)jarg1;
2595   {
2596     try {
2597       result = (float *)floatp_cast(arg1);
2598     } CALL_CATCH_EXCEPTION(0);
2599   }
2600
2601   jresult = (void *)result;
2602   return jresult;
2603 }
2604
2605
2606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_frompointer(void * jarg1) {
2607   void * jresult ;
2608   float *arg1 = (float *) 0 ;
2609   floatp *result = 0 ;
2610
2611   arg1 = (float *)jarg1;
2612   {
2613     try {
2614       result = (floatp *)floatp_frompointer(arg1);
2615     } CALL_CATCH_EXCEPTION(0);
2616   }
2617
2618   jresult = (void *)result;
2619   return jresult;
2620 }
2621
2622
2623 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_intp() {
2624   void * jresult ;
2625   intp *result = 0 ;
2626
2627   {
2628     try {
2629       result = (intp *)new_intp();
2630     } CALL_CATCH_EXCEPTION(0);
2631   }
2632
2633   jresult = (void *)result;
2634   return jresult;
2635 }
2636
2637
2638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_intp(void * jarg1) {
2639   intp *arg1 = (intp *) 0 ;
2640
2641   arg1 = (intp *)jarg1;
2642   {
2643     try {
2644       delete_intp(arg1);
2645     } CALL_CATCH_EXCEPTION();
2646   }
2647
2648 }
2649
2650
2651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_intp_assign(void * jarg1, int jarg2) {
2652   intp *arg1 = (intp *) 0 ;
2653   int arg2 ;
2654
2655   arg1 = (intp *)jarg1;
2656   arg2 = (int)jarg2;
2657   {
2658     try {
2659       intp_assign(arg1,arg2);
2660     } CALL_CATCH_EXCEPTION();
2661   }
2662
2663 }
2664
2665
2666 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_intp_value(void * jarg1) {
2667   int jresult ;
2668   intp *arg1 = (intp *) 0 ;
2669   int result;
2670
2671   arg1 = (intp *)jarg1;
2672   {
2673     try {
2674       result = (int)intp_value(arg1);
2675     } CALL_CATCH_EXCEPTION(0);
2676   }
2677
2678   jresult = result;
2679   return jresult;
2680 }
2681
2682
2683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_cast(void * jarg1) {
2684   void * jresult ;
2685   intp *arg1 = (intp *) 0 ;
2686   int *result = 0 ;
2687
2688   arg1 = (intp *)jarg1;
2689   {
2690     try {
2691       result = (int *)intp_cast(arg1);
2692     } CALL_CATCH_EXCEPTION(0);
2693   }
2694
2695   jresult = (void *)result;
2696   return jresult;
2697 }
2698
2699
2700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_frompointer(void * jarg1) {
2701   void * jresult ;
2702   int *arg1 = (int *) 0 ;
2703   intp *result = 0 ;
2704
2705   arg1 = (int *)jarg1;
2706   {
2707     try {
2708       result = (intp *)intp_frompointer(arg1);
2709     } CALL_CATCH_EXCEPTION(0);
2710   }
2711
2712   jresult = (void *)result;
2713   return jresult;
2714 }
2715
2716
2717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_doublep() {
2718   void * jresult ;
2719   doublep *result = 0 ;
2720
2721   {
2722     try {
2723       result = (doublep *)new_doublep();
2724     } CALL_CATCH_EXCEPTION(0);
2725   }
2726
2727   jresult = (void *)result;
2728   return jresult;
2729 }
2730
2731
2732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_doublep(void * jarg1) {
2733   doublep *arg1 = (doublep *) 0 ;
2734
2735   arg1 = (doublep *)jarg1;
2736   {
2737     try {
2738       delete_doublep(arg1);
2739     } CALL_CATCH_EXCEPTION();
2740   }
2741
2742 }
2743
2744
2745 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_doublep_assign(void * jarg1, double jarg2) {
2746   doublep *arg1 = (doublep *) 0 ;
2747   double arg2 ;
2748
2749   arg1 = (doublep *)jarg1;
2750   arg2 = (double)jarg2;
2751   {
2752     try {
2753       doublep_assign(arg1,arg2);
2754     } CALL_CATCH_EXCEPTION();
2755   }
2756
2757 }
2758
2759
2760 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_doublep_value(void * jarg1) {
2761   double jresult ;
2762   doublep *arg1 = (doublep *) 0 ;
2763   double result;
2764
2765   arg1 = (doublep *)jarg1;
2766   {
2767     try {
2768       result = (double)doublep_value(arg1);
2769     } CALL_CATCH_EXCEPTION(0);
2770   }
2771
2772   jresult = result;
2773   return jresult;
2774 }
2775
2776
2777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_cast(void * jarg1) {
2778   void * jresult ;
2779   doublep *arg1 = (doublep *) 0 ;
2780   double *result = 0 ;
2781
2782   arg1 = (doublep *)jarg1;
2783   {
2784     try {
2785       result = (double *)doublep_cast(arg1);
2786     } CALL_CATCH_EXCEPTION(0);
2787   }
2788
2789   jresult = (void *)result;
2790   return jresult;
2791 }
2792
2793
2794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_frompointer(void * jarg1) {
2795   void * jresult ;
2796   double *arg1 = (double *) 0 ;
2797   doublep *result = 0 ;
2798
2799   arg1 = (double *)jarg1;
2800   {
2801     try {
2802       result = (doublep *)doublep_frompointer(arg1);
2803     } CALL_CATCH_EXCEPTION(0);
2804   }
2805
2806   jresult = (void *)result;
2807   return jresult;
2808 }
2809
2810
2811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_uintp() {
2812   void * jresult ;
2813   uintp *result = 0 ;
2814
2815   {
2816     try {
2817       result = (uintp *)new_uintp();
2818     } CALL_CATCH_EXCEPTION(0);
2819   }
2820
2821   jresult = (void *)result;
2822   return jresult;
2823 }
2824
2825
2826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_uintp(void * jarg1) {
2827   uintp *arg1 = (uintp *) 0 ;
2828
2829   arg1 = (uintp *)jarg1;
2830   {
2831     try {
2832       delete_uintp(arg1);
2833     } CALL_CATCH_EXCEPTION();
2834   }
2835
2836 }
2837
2838
2839 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_uintp_assign(void * jarg1, unsigned int jarg2) {
2840   uintp *arg1 = (uintp *) 0 ;
2841   unsigned int arg2 ;
2842
2843   arg1 = (uintp *)jarg1;
2844   arg2 = (unsigned int)jarg2;
2845   {
2846     try {
2847       uintp_assign(arg1,arg2);
2848     } CALL_CATCH_EXCEPTION();
2849   }
2850
2851 }
2852
2853
2854 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_uintp_value(void * jarg1) {
2855   unsigned int jresult ;
2856   uintp *arg1 = (uintp *) 0 ;
2857   unsigned int result;
2858
2859   arg1 = (uintp *)jarg1;
2860   {
2861     try {
2862       result = (unsigned int)uintp_value(arg1);
2863     } CALL_CATCH_EXCEPTION(0);
2864   }
2865
2866   jresult = result;
2867   return jresult;
2868 }
2869
2870
2871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_cast(void * jarg1) {
2872   void * jresult ;
2873   uintp *arg1 = (uintp *) 0 ;
2874   unsigned int *result = 0 ;
2875
2876   arg1 = (uintp *)jarg1;
2877   {
2878     try {
2879       result = (unsigned int *)uintp_cast(arg1);
2880     } CALL_CATCH_EXCEPTION(0);
2881   }
2882
2883   jresult = (void *)result;
2884   return jresult;
2885 }
2886
2887
2888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_frompointer(void * jarg1) {
2889   void * jresult ;
2890   unsigned int *arg1 = (unsigned int *) 0 ;
2891   uintp *result = 0 ;
2892
2893   arg1 = (unsigned int *)jarg1;
2894   {
2895     try {
2896       result = (uintp *)uintp_frompointer(arg1);
2897     } CALL_CATCH_EXCEPTION(0);
2898   }
2899
2900   jresult = (void *)result;
2901   return jresult;
2902 }
2903
2904
2905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ushortp() {
2906   void * jresult ;
2907   ushortp *result = 0 ;
2908
2909   {
2910     try {
2911       result = (ushortp *)new_ushortp();
2912     } CALL_CATCH_EXCEPTION(0);
2913   }
2914
2915   jresult = (void *)result;
2916   return jresult;
2917 }
2918
2919
2920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ushortp(void * jarg1) {
2921   ushortp *arg1 = (ushortp *) 0 ;
2922
2923   arg1 = (ushortp *)jarg1;
2924   {
2925     try {
2926       delete_ushortp(arg1);
2927     } CALL_CATCH_EXCEPTION();
2928   }
2929
2930 }
2931
2932
2933 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ushortp_assign(void * jarg1, unsigned short jarg2) {
2934   ushortp *arg1 = (ushortp *) 0 ;
2935   unsigned short arg2 ;
2936
2937   arg1 = (ushortp *)jarg1;
2938   arg2 = (unsigned short)jarg2;
2939   {
2940     try {
2941       ushortp_assign(arg1,arg2);
2942     } CALL_CATCH_EXCEPTION();
2943   }
2944
2945 }
2946
2947
2948 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_ushortp_value(void * jarg1) {
2949   unsigned short jresult ;
2950   ushortp *arg1 = (ushortp *) 0 ;
2951   unsigned short result;
2952
2953   arg1 = (ushortp *)jarg1;
2954   {
2955     try {
2956       result = (unsigned short)ushortp_value(arg1);
2957     } CALL_CATCH_EXCEPTION(0);
2958   }
2959
2960   jresult = result;
2961   return jresult;
2962 }
2963
2964
2965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_cast(void * jarg1) {
2966   void * jresult ;
2967   ushortp *arg1 = (ushortp *) 0 ;
2968   unsigned short *result = 0 ;
2969
2970   arg1 = (ushortp *)jarg1;
2971   {
2972     try {
2973       result = (unsigned short *)ushortp_cast(arg1);
2974     } CALL_CATCH_EXCEPTION(0);
2975   }
2976
2977   jresult = (void *)result;
2978   return jresult;
2979 }
2980
2981
2982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_frompointer(void * jarg1) {
2983   void * jresult ;
2984   unsigned short *arg1 = (unsigned short *) 0 ;
2985   ushortp *result = 0 ;
2986
2987   arg1 = (unsigned short *)jarg1;
2988   {
2989     try {
2990       result = (ushortp *)ushortp_frompointer(arg1);
2991     } CALL_CATCH_EXCEPTION(0);
2992   }
2993
2994   jresult = (void *)result;
2995   return jresult;
2996 }
2997
2998
2999 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_int_to_uint(int jarg1) {
3000   unsigned int jresult ;
3001   int arg1 ;
3002   unsigned int result;
3003
3004   arg1 = (int)jarg1;
3005   {
3006     try {
3007       result = (unsigned int)int_to_uint(arg1);
3008     } CALL_CATCH_EXCEPTION(0);
3009   }
3010
3011   jresult = result;
3012   return jresult;
3013 }
3014
3015
3016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Reference(void * jarg1) {
3017   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3018
3019   arg1 = (Dali::RefObject *)jarg1;
3020   {
3021     try {
3022       (arg1)->Reference();
3023     } CALL_CATCH_EXCEPTION();
3024   }
3025
3026 }
3027
3028
3029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Unreference(void * jarg1) {
3030   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3031
3032   arg1 = (Dali::RefObject *)jarg1;
3033   {
3034     try {
3035       (arg1)->Unreference();
3036     } CALL_CATCH_EXCEPTION();
3037   }
3038
3039 }
3040
3041
3042 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RefObject_ReferenceCount(void * jarg1) {
3043   int jresult ;
3044   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3045   int result;
3046
3047   arg1 = (Dali::RefObject *)jarg1;
3048   {
3049     try {
3050       result = (int)(arg1)->ReferenceCount();
3051     } CALL_CATCH_EXCEPTION(0);
3052   }
3053
3054   jresult = result;
3055   return jresult;
3056 }
3057
3058
3059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_0() {
3060   void * jresult ;
3061   Dali::Any *result = 0 ;
3062
3063   {
3064     try {
3065       result = (Dali::Any *)new Dali::Any();
3066     } CALL_CATCH_EXCEPTION(0);
3067   }
3068
3069   jresult = (void *)result;
3070   return jresult;
3071 }
3072
3073
3074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any(void * jarg1) {
3075   Dali::Any *arg1 = (Dali::Any *) 0 ;
3076
3077   arg1 = (Dali::Any *)jarg1;
3078   {
3079     try {
3080       delete arg1;
3081     } CALL_CATCH_EXCEPTION();
3082   }
3083
3084 }
3085
3086
3087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AssertAlways(char * jarg1) {
3088   char *arg1 = (char *) 0 ;
3089
3090   arg1 = (char *)jarg1;
3091   {
3092     try {
3093       Dali::Any::AssertAlways((char const *)arg1);
3094     } CALL_CATCH_EXCEPTION();
3095   }
3096
3097 }
3098
3099
3100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_2(void * jarg1) {
3101   void * jresult ;
3102   Dali::Any *arg1 = 0 ;
3103   Dali::Any *result = 0 ;
3104
3105   arg1 = (Dali::Any *)jarg1;
3106   if (!arg1) {
3107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3108     return 0;
3109   }
3110   {
3111     try {
3112       result = (Dali::Any *)new Dali::Any((Dali::Any const &)*arg1);
3113     } CALL_CATCH_EXCEPTION(0);
3114   }
3115
3116   jresult = (void *)result;
3117   return jresult;
3118 }
3119
3120
3121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_Assign(void * jarg1, void * jarg2) {
3122   void * jresult ;
3123   Dali::Any *arg1 = (Dali::Any *) 0 ;
3124   Dali::Any *arg2 = 0 ;
3125   Dali::Any *result = 0 ;
3126
3127   arg1 = (Dali::Any *)jarg1;
3128   arg2 = (Dali::Any *)jarg2;
3129   if (!arg2) {
3130     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3131     return 0;
3132   }
3133   {
3134     try {
3135       result = (Dali::Any *) &(arg1)->operator =((Dali::Any const &)*arg2);
3136     } CALL_CATCH_EXCEPTION(0);
3137   }
3138
3139   jresult = (void *)result;
3140   return jresult;
3141 }
3142
3143
3144 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_GetType(void * jarg1) {
3145   void * jresult ;
3146   Dali::Any *arg1 = (Dali::Any *) 0 ;
3147   std::type_info *result = 0 ;
3148
3149   arg1 = (Dali::Any *)jarg1;
3150   {
3151     try {
3152       result = (std::type_info *) &((Dali::Any const *)arg1)->GetType();
3153     } CALL_CATCH_EXCEPTION(0);
3154   }
3155
3156   jresult = (void *)result;
3157   return jresult;
3158 }
3159
3160
3161 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Any_Empty(void * jarg1) {
3162   unsigned int jresult ;
3163   Dali::Any *arg1 = (Dali::Any *) 0 ;
3164   bool result;
3165
3166   arg1 = (Dali::Any *)jarg1;
3167   {
3168     try {
3169       result = (bool)((Dali::Any const *)arg1)->Empty();
3170     } CALL_CATCH_EXCEPTION(0);
3171   }
3172
3173   jresult = result;
3174   return jresult;
3175 }
3176
3177
3178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any_AnyContainerBase(void * jarg1, void * jarg2, void * jarg3) {
3179   void * jresult ;
3180   std::type_info *arg1 = 0 ;
3181   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3182   Dali::Any::DeleteFunc arg3 = (Dali::Any::DeleteFunc) 0 ;
3183   Dali::Any::AnyContainerBase *result = 0 ;
3184
3185   arg1 = (std::type_info *)jarg1;
3186   if (!arg1) {
3187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
3188     return 0;
3189   }
3190   arg2 = (Dali::Any::CloneFunc)jarg2;
3191   arg3 = (Dali::Any::DeleteFunc)jarg3;
3192   {
3193     try {
3194       result = (Dali::Any::AnyContainerBase *)new Dali::Any::AnyContainerBase((std::type_info const &)*arg1,arg2,arg3);
3195     } CALL_CATCH_EXCEPTION(0);
3196   }
3197
3198   jresult = (void *)result;
3199   return jresult;
3200 }
3201
3202
3203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_GetType(void * jarg1) {
3204   void * jresult ;
3205   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3206   std::type_info *result = 0 ;
3207
3208   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3209   {
3210     try {
3211       result = (std::type_info *) &((Dali::Any::AnyContainerBase const *)arg1)->GetType();
3212     } CALL_CATCH_EXCEPTION(0);
3213   }
3214
3215   jresult = (void *)result;
3216   return jresult;
3217 }
3218
3219
3220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mType_get(void * jarg1) {
3221   void * jresult ;
3222   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3223   ::std::type_info *result = 0 ;
3224
3225   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3226   result = (::std::type_info *) &(::std::type_info const &) ((arg1)->mType);
3227   jresult = (void *)result;
3228   return jresult;
3229 }
3230
3231
3232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_set(void * jarg1, void * jarg2) {
3233   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3234   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3235
3236   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3237   arg2 = (Dali::Any::CloneFunc)jarg2;
3238   if (arg1) (arg1)->mCloneFunc = arg2;
3239 }
3240
3241
3242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_get(void * jarg1) {
3243   void * jresult ;
3244   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3245   Dali::Any::CloneFunc result;
3246
3247   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3248   result = (Dali::Any::CloneFunc) ((arg1)->mCloneFunc);
3249   jresult = (void *)result;
3250   return jresult;
3251 }
3252
3253
3254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_set(void * jarg1, void * jarg2) {
3255   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3256   Dali::Any::DeleteFunc arg2 = (Dali::Any::DeleteFunc) 0 ;
3257
3258   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3259   arg2 = (Dali::Any::DeleteFunc)jarg2;
3260   if (arg1) (arg1)->mDeleteFunc = arg2;
3261 }
3262
3263
3264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_get(void * jarg1) {
3265   void * jresult ;
3266   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3267   Dali::Any::DeleteFunc result;
3268
3269   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3270   result = (Dali::Any::DeleteFunc) ((arg1)->mDeleteFunc);
3271   jresult = (void *)result;
3272   return jresult;
3273 }
3274
3275
3276 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any_AnyContainerBase(void * jarg1) {
3277   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3278
3279   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3280   {
3281     try {
3282       delete arg1;
3283     } CALL_CATCH_EXCEPTION();
3284   }
3285
3286 }
3287
3288
3289 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_mContainer_set(void * jarg1, void * jarg2) {
3290   Dali::Any *arg1 = (Dali::Any *) 0 ;
3291   Dali::Any::AnyContainerBase *arg2 = (Dali::Any::AnyContainerBase *) 0 ;
3292
3293   arg1 = (Dali::Any *)jarg1;
3294   arg2 = (Dali::Any::AnyContainerBase *)jarg2;
3295   if (arg1) (arg1)->mContainer = arg2;
3296 }
3297
3298
3299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_mContainer_get(void * jarg1) {
3300   void * jresult ;
3301   Dali::Any *arg1 = (Dali::Any *) 0 ;
3302   Dali::Any::AnyContainerBase *result = 0 ;
3303
3304   arg1 = (Dali::Any *)jarg1;
3305   result = (Dali::Any::AnyContainerBase *) ((arg1)->mContainer);
3306   jresult = (void *)result;
3307   return jresult;
3308 }
3309
3310
3311 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliAssertMessage(char * jarg1, char * jarg2) {
3312   char *arg1 = (char *) 0 ;
3313   char *arg2 = (char *) 0 ;
3314
3315   arg1 = (char *)jarg1;
3316   arg2 = (char *)jarg2;
3317   {
3318     try {
3319       Dali::DaliAssertMessage((char const *)arg1,(char const *)arg2);
3320     } CALL_CATCH_EXCEPTION();
3321   }
3322
3323 }
3324
3325
3326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DaliException(char * jarg1, char * jarg2) {
3327   void * jresult ;
3328   char *arg1 = (char *) 0 ;
3329   char *arg2 = (char *) 0 ;
3330   Dali::DaliException *result = 0 ;
3331
3332   arg1 = (char *)jarg1;
3333   arg2 = (char *)jarg2;
3334   {
3335     try {
3336       result = (Dali::DaliException *)new Dali::DaliException((char const *)arg1,(char const *)arg2);
3337     } CALL_CATCH_EXCEPTION(0);
3338   }
3339
3340   jresult = (void *)result;
3341   return jresult;
3342 }
3343
3344
3345 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_location_set(void * jarg1, char * jarg2) {
3346   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3347   std::string arg2 = std::string(jarg2);
3348
3349   arg1 = (Dali::DaliException *)jarg1;
3350   {
3351     if (!arg2.empty()) {
3352       ((char *)(arg1->location))[arg2.copy((char*)(arg1->location), strlen(arg1->location)-1)] = '\0';
3353     } else {
3354       arg1->location = 0;
3355     }
3356   }
3357 }
3358
3359 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_location_get(void * jarg1) {
3360   char * jresult ;
3361   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3362   char *result = 0 ;
3363
3364   arg1 = (Dali::DaliException *)jarg1;
3365   result = (char *) ((arg1)->location);
3366   jresult = SWIG_csharp_string_callback((const char *)result);
3367   return jresult;
3368 }
3369
3370
3371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_condition_set(void * jarg1, char * jarg2) {
3372   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3373   std::string arg2 = std::string(jarg2);
3374
3375   arg1 = (Dali::DaliException *)jarg1;
3376   {
3377     if (!arg2.empty()) {
3378       ((char *)(arg1->condition))[arg2.copy((char*)(arg1->condition), strlen(arg1->condition)-1)] = '\0';
3379     } else {
3380       arg1->condition = 0;
3381     }
3382   }
3383 }
3384
3385
3386 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_condition_get(void * jarg1) {
3387   char * jresult ;
3388   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3389   char *result = 0 ;
3390
3391   arg1 = (Dali::DaliException *)jarg1;
3392   result = (char *) ((arg1)->condition);
3393   jresult = SWIG_csharp_string_callback((const char *)result);
3394   return jresult;
3395 }
3396
3397
3398 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DaliException(void * jarg1) {
3399   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3400
3401   arg1 = (Dali::DaliException *)jarg1;
3402   {
3403     try {
3404       delete arg1;
3405     } CALL_CATCH_EXCEPTION();
3406   }
3407
3408 }
3409
3410
3411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_0() {
3412   void * jresult ;
3413   Dali::Vector2 *result = 0 ;
3414
3415   {
3416     try {
3417       result = (Dali::Vector2 *)new Dali::Vector2();
3418     } CALL_CATCH_EXCEPTION(0);
3419   }
3420
3421   jresult = (void *)result;
3422   return jresult;
3423 }
3424
3425
3426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_1(float jarg1, float jarg2) {
3427   void * jresult ;
3428   float arg1 ;
3429   float arg2 ;
3430   Dali::Vector2 *result = 0 ;
3431
3432   arg1 = (float)jarg1;
3433   arg2 = (float)jarg2;
3434   {
3435     try {
3436       result = (Dali::Vector2 *)new Dali::Vector2(arg1,arg2);
3437     } CALL_CATCH_EXCEPTION(0);
3438   }
3439
3440   jresult = (void *)result;
3441   return jresult;
3442 }
3443
3444
3445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_2(float* jarg1) {
3446   void * jresult ;
3447   float *arg1 = (float *) 0 ;
3448   Dali::Vector2 *result = 0 ;
3449
3450   arg1 = jarg1;
3451   {
3452     try {
3453       result = (Dali::Vector2 *)new Dali::Vector2((float const *)arg1);
3454     } CALL_CATCH_EXCEPTION(0);
3455   }
3456
3457   jresult = (void *)result;
3458
3459
3460   return jresult;
3461 }
3462
3463
3464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_3(void * jarg1) {
3465   void * jresult ;
3466   Dali::Vector3 *arg1 = 0 ;
3467   Dali::Vector2 *result = 0 ;
3468
3469   arg1 = (Dali::Vector3 *)jarg1;
3470   if (!arg1) {
3471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
3472     return 0;
3473   }
3474   {
3475     try {
3476       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector3 const &)*arg1);
3477     } CALL_CATCH_EXCEPTION(0);
3478   }
3479
3480   jresult = (void *)result;
3481   return jresult;
3482 }
3483
3484
3485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_4(void * jarg1) {
3486   void * jresult ;
3487   Dali::Vector4 *arg1 = 0 ;
3488   Dali::Vector2 *result = 0 ;
3489
3490   arg1 = (Dali::Vector4 *)jarg1;
3491   if (!arg1) {
3492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
3493     return 0;
3494   }
3495   {
3496     try {
3497       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector4 const &)*arg1);
3498     } CALL_CATCH_EXCEPTION(0);
3499   }
3500
3501   jresult = (void *)result;
3502   return jresult;
3503 }
3504
3505
3506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ONE_get() {
3507   void * jresult ;
3508   Dali::Vector2 *result = 0 ;
3509
3510   result = (Dali::Vector2 *)&Dali::Vector2::ONE;
3511   jresult = (void *)result;
3512   return jresult;
3513 }
3514
3515
3516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_XAXIS_get() {
3517   void * jresult ;
3518   Dali::Vector2 *result = 0 ;
3519
3520   result = (Dali::Vector2 *)&Dali::Vector2::XAXIS;
3521   jresult = (void *)result;
3522   return jresult;
3523 }
3524
3525
3526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_YAXIS_get() {
3527   void * jresult ;
3528   Dali::Vector2 *result = 0 ;
3529
3530   result = (Dali::Vector2 *)&Dali::Vector2::YAXIS;
3531   jresult = (void *)result;
3532   return jresult;
3533 }
3534
3535
3536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_XAXIS_get() {
3537   void * jresult ;
3538   Dali::Vector2 *result = 0 ;
3539
3540   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_XAXIS;
3541   jresult = (void *)result;
3542   return jresult;
3543 }
3544
3545
3546 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_YAXIS_get() {
3547   void * jresult ;
3548   Dali::Vector2 *result = 0 ;
3549
3550   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_YAXIS;
3551   jresult = (void *)result;
3552   return jresult;
3553 }
3554
3555
3556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ZERO_get() {
3557   void * jresult ;
3558   Dali::Vector2 *result = 0 ;
3559
3560   result = (Dali::Vector2 *)&Dali::Vector2::ZERO;
3561   jresult = (void *)result;
3562   return jresult;
3563 }
3564
3565
3566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_0(void * jarg1, float* jarg2) {
3567   void * jresult ;
3568   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3569   float *arg2 = (float *) 0 ;
3570   Dali::Vector2 *result = 0 ;
3571
3572   arg1 = (Dali::Vector2 *)jarg1;
3573   arg2 = jarg2;
3574   {
3575     try {
3576       result = (Dali::Vector2 *) &(arg1)->operator =((float const *)arg2);
3577     } CALL_CATCH_EXCEPTION(0);
3578   }
3579
3580   jresult = (void *)result;
3581
3582
3583   return jresult;
3584 }
3585
3586
3587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_1(void * jarg1, void * jarg2) {
3588   void * jresult ;
3589   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3590   Dali::Vector3 *arg2 = 0 ;
3591   Dali::Vector2 *result = 0 ;
3592
3593   arg1 = (Dali::Vector2 *)jarg1;
3594   arg2 = (Dali::Vector3 *)jarg2;
3595   if (!arg2) {
3596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
3597     return 0;
3598   }
3599   {
3600     try {
3601       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
3602     } CALL_CATCH_EXCEPTION(0);
3603   }
3604
3605   jresult = (void *)result;
3606   return jresult;
3607 }
3608
3609
3610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_2(void * jarg1, void * jarg2) {
3611   void * jresult ;
3612   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3613   Dali::Vector4 *arg2 = 0 ;
3614   Dali::Vector2 *result = 0 ;
3615
3616   arg1 = (Dali::Vector2 *)jarg1;
3617   arg2 = (Dali::Vector4 *)jarg2;
3618   if (!arg2) {
3619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
3620     return 0;
3621   }
3622   {
3623     try {
3624       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
3625     } CALL_CATCH_EXCEPTION(0);
3626   }
3627
3628   jresult = (void *)result;
3629   return jresult;
3630 }
3631
3632
3633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Add(void * jarg1, void * jarg2) {
3634   void * jresult ;
3635   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3636   Dali::Vector2 *arg2 = 0 ;
3637   Dali::Vector2 result;
3638
3639   arg1 = (Dali::Vector2 *)jarg1;
3640   arg2 = (Dali::Vector2 *)jarg2;
3641   if (!arg2) {
3642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3643     return 0;
3644   }
3645   {
3646     try {
3647       result = ((Dali::Vector2 const *)arg1)->operator +((Dali::Vector2 const &)*arg2);
3648     } CALL_CATCH_EXCEPTION(0);
3649   }
3650
3651   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
3652   return jresult;
3653 }
3654
3655
3656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AddAssign(void * jarg1, void * jarg2) {
3657   void * jresult ;
3658   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3659   Dali::Vector2 *arg2 = 0 ;
3660   Dali::Vector2 *result = 0 ;
3661
3662   arg1 = (Dali::Vector2 *)jarg1;
3663   arg2 = (Dali::Vector2 *)jarg2;
3664   if (!arg2) {
3665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3666     return 0;
3667   }
3668   {
3669     try {
3670       result = (Dali::Vector2 *) &(arg1)->operator +=((Dali::Vector2 const &)*arg2);
3671     } CALL_CATCH_EXCEPTION(0);
3672   }
3673
3674   jresult = (void *)result;
3675   return jresult;
3676 }
3677
3678
3679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_0(void * jarg1, void * jarg2) {
3680   void * jresult ;
3681   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3682   Dali::Vector2 *arg2 = 0 ;
3683   Dali::Vector2 result;
3684
3685   arg1 = (Dali::Vector2 *)jarg1;
3686   arg2 = (Dali::Vector2 *)jarg2;
3687   if (!arg2) {
3688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3689     return 0;
3690   }
3691   {
3692     try {
3693       result = ((Dali::Vector2 const *)arg1)->operator -((Dali::Vector2 const &)*arg2);
3694     } CALL_CATCH_EXCEPTION(0);
3695   }
3696
3697   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
3698   return jresult;
3699 }
3700
3701
3702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_SubtractAssign(void * jarg1, void * jarg2) {
3703   void * jresult ;
3704   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3705   Dali::Vector2 *arg2 = 0 ;
3706   Dali::Vector2 *result = 0 ;
3707
3708   arg1 = (Dali::Vector2 *)jarg1;
3709   arg2 = (Dali::Vector2 *)jarg2;
3710   if (!arg2) {
3711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3712     return 0;
3713   }
3714   {
3715     try {
3716       result = (Dali::Vector2 *) &(arg1)->operator -=((Dali::Vector2 const &)*arg2);
3717     } CALL_CATCH_EXCEPTION(0);
3718   }
3719
3720   jresult = (void *)result;
3721   return jresult;
3722 }
3723
3724
3725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_0(void * jarg1, void * jarg2) {
3726   void * jresult ;
3727   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3728   Dali::Vector2 *arg2 = 0 ;
3729   Dali::Vector2 result;
3730
3731   arg1 = (Dali::Vector2 *)jarg1;
3732   arg2 = (Dali::Vector2 *)jarg2;
3733   if (!arg2) {
3734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3735     return 0;
3736   }
3737   {
3738     try {
3739       result = ((Dali::Vector2 const *)arg1)->operator *((Dali::Vector2 const &)*arg2);
3740     } CALL_CATCH_EXCEPTION(0);
3741   }
3742
3743   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
3744   return jresult;
3745 }
3746
3747
3748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_1(void * jarg1, float jarg2) {
3749   void * jresult ;
3750   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3751   float arg2 ;
3752   Dali::Vector2 result;
3753
3754   arg1 = (Dali::Vector2 *)jarg1;
3755   arg2 = (float)jarg2;
3756   {
3757     try {
3758       result = ((Dali::Vector2 const *)arg1)->operator *(arg2);
3759     } CALL_CATCH_EXCEPTION(0);
3760   }
3761
3762   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
3763   return jresult;
3764 }
3765
3766
3767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
3768   void * jresult ;
3769   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3770   Dali::Vector2 *arg2 = 0 ;
3771   Dali::Vector2 *result = 0 ;
3772
3773   arg1 = (Dali::Vector2 *)jarg1;
3774   arg2 = (Dali::Vector2 *)jarg2;
3775   if (!arg2) {
3776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3777     return 0;
3778   }
3779   {
3780     try {
3781       result = (Dali::Vector2 *) &(arg1)->operator *=((Dali::Vector2 const &)*arg2);
3782     } CALL_CATCH_EXCEPTION(0);
3783   }
3784
3785   jresult = (void *)result;
3786   return jresult;
3787 }
3788
3789
3790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
3791   void * jresult ;
3792   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3793   float arg2 ;
3794   Dali::Vector2 *result = 0 ;
3795
3796   arg1 = (Dali::Vector2 *)jarg1;
3797   arg2 = (float)jarg2;
3798   {
3799     try {
3800       result = (Dali::Vector2 *) &(arg1)->operator *=(arg2);
3801     } CALL_CATCH_EXCEPTION(0);
3802   }
3803
3804   jresult = (void *)result;
3805   return jresult;
3806 }
3807
3808
3809 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_0(void * jarg1, void * jarg2) {
3810   void * jresult ;
3811   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3812   Dali::Vector2 *arg2 = 0 ;
3813   Dali::Vector2 result;
3814
3815   arg1 = (Dali::Vector2 *)jarg1;
3816   arg2 = (Dali::Vector2 *)jarg2;
3817   if (!arg2) {
3818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3819     return 0;
3820   }
3821   {
3822     try {
3823       result = ((Dali::Vector2 const *)arg1)->operator /((Dali::Vector2 const &)*arg2);
3824     } CALL_CATCH_EXCEPTION(0);
3825   }
3826
3827   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
3828   return jresult;
3829 }
3830
3831
3832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_1(void * jarg1, float jarg2) {
3833   void * jresult ;
3834   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3835   float arg2 ;
3836   Dali::Vector2 result;
3837
3838   arg1 = (Dali::Vector2 *)jarg1;
3839   arg2 = (float)jarg2;
3840   {
3841     try {
3842       result = ((Dali::Vector2 const *)arg1)->operator /(arg2);
3843     } CALL_CATCH_EXCEPTION(0);
3844   }
3845
3846   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
3847   return jresult;
3848 }
3849
3850
3851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
3852   void * jresult ;
3853   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3854   Dali::Vector2 *arg2 = 0 ;
3855   Dali::Vector2 *result = 0 ;
3856
3857   arg1 = (Dali::Vector2 *)jarg1;
3858   arg2 = (Dali::Vector2 *)jarg2;
3859   if (!arg2) {
3860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3861     return 0;
3862   }
3863   {
3864     try {
3865       result = (Dali::Vector2 *) &(arg1)->operator /=((Dali::Vector2 const &)*arg2);
3866     } CALL_CATCH_EXCEPTION(0);
3867   }
3868
3869   jresult = (void *)result;
3870   return jresult;
3871 }
3872
3873
3874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
3875   void * jresult ;
3876   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3877   float arg2 ;
3878   Dali::Vector2 *result = 0 ;
3879
3880   arg1 = (Dali::Vector2 *)jarg1;
3881   arg2 = (float)jarg2;
3882   {
3883     try {
3884       result = (Dali::Vector2 *) &(arg1)->operator /=(arg2);
3885     } CALL_CATCH_EXCEPTION(0);
3886   }
3887
3888   jresult = (void *)result;
3889   return jresult;
3890 }
3891
3892
3893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_1(void * jarg1) {
3894   void * jresult ;
3895   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3896   Dali::Vector2 result;
3897
3898   arg1 = (Dali::Vector2 *)jarg1;
3899   {
3900     try {
3901       result = ((Dali::Vector2 const *)arg1)->operator -();
3902     } CALL_CATCH_EXCEPTION(0);
3903   }
3904
3905   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
3906   return jresult;
3907 }
3908
3909
3910 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_EqualTo(void * jarg1, void * jarg2) {
3911   unsigned int jresult ;
3912   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3913   Dali::Vector2 *arg2 = 0 ;
3914   bool result;
3915
3916   arg1 = (Dali::Vector2 *)jarg1;
3917   arg2 = (Dali::Vector2 *)jarg2;
3918   if (!arg2) {
3919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3920     return 0;
3921   }
3922   {
3923     try {
3924       result = (bool)((Dali::Vector2 const *)arg1)->operator ==((Dali::Vector2 const &)*arg2);
3925     } CALL_CATCH_EXCEPTION(0);
3926   }
3927
3928   jresult = result;
3929   return jresult;
3930 }
3931
3932
3933 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_NotEqualTo(void * jarg1, void * jarg2) {
3934   unsigned int jresult ;
3935   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3936   Dali::Vector2 *arg2 = 0 ;
3937   bool result;
3938
3939   arg1 = (Dali::Vector2 *)jarg1;
3940   arg2 = (Dali::Vector2 *)jarg2;
3941   if (!arg2) {
3942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
3943     return 0;
3944   }
3945   {
3946     try {
3947       result = (bool)((Dali::Vector2 const *)arg1)->operator !=((Dali::Vector2 const &)*arg2);
3948     } CALL_CATCH_EXCEPTION(0);
3949   }
3950
3951   jresult = result;
3952   return jresult;
3953 }
3954
3955
3956 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
3957   float jresult ;
3958   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3959   unsigned int arg2 ;
3960   float *result = 0 ;
3961
3962   arg1 = (Dali::Vector2 *)jarg1;
3963   arg2 = (unsigned int)jarg2;
3964   {
3965     try {
3966       result = (float *) &((Dali::Vector2 const *)arg1)->operator [](arg2);
3967     } CALL_CATCH_EXCEPTION(0);
3968   }
3969
3970   jresult = *result;
3971   return jresult;
3972 }
3973
3974
3975 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Length(void * jarg1) {
3976   float jresult ;
3977   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3978   float result;
3979
3980   arg1 = (Dali::Vector2 *)jarg1;
3981   {
3982     try {
3983       result = (float)((Dali::Vector2 const *)arg1)->Length();
3984     } CALL_CATCH_EXCEPTION(0);
3985   }
3986
3987   jresult = result;
3988   return jresult;
3989 }
3990
3991
3992 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_LengthSquared(void * jarg1) {
3993   float jresult ;
3994   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3995   float result;
3996
3997   arg1 = (Dali::Vector2 *)jarg1;
3998   {
3999     try {
4000       result = (float)((Dali::Vector2 const *)arg1)->LengthSquared();
4001     } CALL_CATCH_EXCEPTION(0);
4002   }
4003
4004   jresult = result;
4005   return jresult;
4006 }
4007
4008
4009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Normalize(void * jarg1) {
4010   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4011
4012   arg1 = (Dali::Vector2 *)jarg1;
4013   {
4014     try {
4015       (arg1)->Normalize();
4016     } CALL_CATCH_EXCEPTION();
4017   }
4018
4019 }
4020
4021
4022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Clamp(void * jarg1, void * jarg2, void * jarg3) {
4023   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4024   Dali::Vector2 *arg2 = 0 ;
4025   Dali::Vector2 *arg3 = 0 ;
4026
4027   arg1 = (Dali::Vector2 *)jarg1;
4028   arg2 = (Dali::Vector2 *)jarg2;
4029   if (!arg2) {
4030     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4031     return ;
4032   }
4033   arg3 = (Dali::Vector2 *)jarg3;
4034   if (!arg3) {
4035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4036     return ;
4037   }
4038   {
4039     try {
4040       (arg1)->Clamp((Dali::Vector2 const &)*arg2,(Dali::Vector2 const &)*arg3);
4041     } CALL_CATCH_EXCEPTION();
4042   }
4043
4044 }
4045
4046
4047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AsFloat__SWIG_0(void * jarg1) {
4048   void * jresult ;
4049   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4050   float *result = 0 ;
4051
4052   arg1 = (Dali::Vector2 *)jarg1;
4053   {
4054     try {
4055       result = (float *)((Dali::Vector2 const *)arg1)->AsFloat();
4056     } CALL_CATCH_EXCEPTION(0);
4057   }
4058
4059   jresult = (void *)result;
4060   return jresult;
4061 }
4062
4063
4064 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_X_set(void * jarg1, float jarg2) {
4065   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4066   float arg2 ;
4067
4068   arg1 = (Dali::Vector2 *)jarg1;
4069   arg2 = (float)jarg2;
4070   if (arg1) (arg1)->x = arg2;
4071 }
4072
4073
4074 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_X_get(void * jarg1) {
4075   float jresult ;
4076   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4077   float result;
4078
4079   arg1 = (Dali::Vector2 *)jarg1;
4080   result = (float) ((arg1)->x);
4081   jresult = result;
4082   return jresult;
4083 }
4084
4085
4086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Width_set(void * jarg1, float jarg2) {
4087   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4088   float arg2 ;
4089
4090   arg1 = (Dali::Vector2 *)jarg1;
4091   arg2 = (float)jarg2;
4092   if (arg1) (arg1)->width = arg2;
4093 }
4094
4095
4096 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Width_get(void * jarg1) {
4097   float jresult ;
4098   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4099   float result;
4100
4101   arg1 = (Dali::Vector2 *)jarg1;
4102   result = (float) ((arg1)->width);
4103   jresult = result;
4104   return jresult;
4105 }
4106
4107
4108 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Y_set(void * jarg1, float jarg2) {
4109   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4110   float arg2 ;
4111
4112   arg1 = (Dali::Vector2 *)jarg1;
4113   arg2 = (float)jarg2;
4114   if (arg1) (arg1)->y = arg2;
4115 }
4116
4117
4118 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Y_get(void * jarg1) {
4119   float jresult ;
4120   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4121   float result;
4122
4123   arg1 = (Dali::Vector2 *)jarg1;
4124   result = (float) ((arg1)->y);
4125   jresult = result;
4126   return jresult;
4127 }
4128
4129
4130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Height_set(void * jarg1, float jarg2) {
4131   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4132   float arg2 ;
4133
4134   arg1 = (Dali::Vector2 *)jarg1;
4135   arg2 = (float)jarg2;
4136   if (arg1) (arg1)->height = arg2;
4137 }
4138
4139
4140 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Height_get(void * jarg1) {
4141   float jresult ;
4142   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4143   float result;
4144
4145   arg1 = (Dali::Vector2 *)jarg1;
4146   result = (float) ((arg1)->height);
4147   jresult = result;
4148   return jresult;
4149 }
4150
4151
4152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector2(void * jarg1) {
4153   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4154
4155   arg1 = (Dali::Vector2 *)jarg1;
4156   {
4157     try {
4158       delete arg1;
4159     } CALL_CATCH_EXCEPTION();
4160   }
4161
4162 }
4163
4164
4165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_0(void * jarg1, void * jarg2) {
4166   void * jresult ;
4167   Dali::Vector2 *arg1 = 0 ;
4168   Dali::Vector2 *arg2 = 0 ;
4169   Dali::Vector2 result;
4170
4171   arg1 = (Dali::Vector2 *)jarg1;
4172   if (!arg1) {
4173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4174     return 0;
4175   }
4176   arg2 = (Dali::Vector2 *)jarg2;
4177   if (!arg2) {
4178     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4179     return 0;
4180   }
4181   {
4182     try {
4183       result = Dali::Min((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
4184     } CALL_CATCH_EXCEPTION(0);
4185   }
4186
4187   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4188   return jresult;
4189 }
4190
4191
4192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_0(void * jarg1, void * jarg2) {
4193   void * jresult ;
4194   Dali::Vector2 *arg1 = 0 ;
4195   Dali::Vector2 *arg2 = 0 ;
4196   Dali::Vector2 result;
4197
4198   arg1 = (Dali::Vector2 *)jarg1;
4199   if (!arg1) {
4200     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4201     return 0;
4202   }
4203   arg2 = (Dali::Vector2 *)jarg2;
4204   if (!arg2) {
4205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4206     return 0;
4207   }
4208   {
4209     try {
4210       result = Dali::Max((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
4211     } CALL_CATCH_EXCEPTION(0);
4212   }
4213
4214   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4215   return jresult;
4216 }
4217
4218
4219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3) {
4220   void * jresult ;
4221   Dali::Vector2 *arg1 = 0 ;
4222   float *arg2 = 0 ;
4223   float *arg3 = 0 ;
4224   float temp2 ;
4225   float temp3 ;
4226   Dali::Vector2 result;
4227
4228   arg1 = (Dali::Vector2 *)jarg1;
4229   if (!arg1) {
4230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4231     return 0;
4232   }
4233   temp2 = (float)jarg2;
4234   arg2 = &temp2;
4235   temp3 = (float)jarg3;
4236   arg3 = &temp3;
4237   {
4238     try {
4239       result = Dali::Clamp((Dali::Vector2 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
4240     } CALL_CATCH_EXCEPTION(0);
4241   }
4242
4243   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4244   return jresult;
4245 }
4246
4247
4248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_0() {
4249   void * jresult ;
4250   Dali::Vector3 *result = 0 ;
4251
4252   {
4253     try {
4254       result = (Dali::Vector3 *)new Dali::Vector3();
4255     } CALL_CATCH_EXCEPTION(0);
4256   }
4257
4258   jresult = (void *)result;
4259   return jresult;
4260 }
4261
4262
4263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_1(float jarg1, float jarg2, float jarg3) {
4264   void * jresult ;
4265   float arg1 ;
4266   float arg2 ;
4267   float arg3 ;
4268   Dali::Vector3 *result = 0 ;
4269
4270   arg1 = (float)jarg1;
4271   arg2 = (float)jarg2;
4272   arg3 = (float)jarg3;
4273   {
4274     try {
4275       result = (Dali::Vector3 *)new Dali::Vector3(arg1,arg2,arg3);
4276     } CALL_CATCH_EXCEPTION(0);
4277   }
4278
4279   jresult = (void *)result;
4280   return jresult;
4281 }
4282
4283
4284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_2(float* jarg1) {
4285   void * jresult ;
4286   float *arg1 = (float *) 0 ;
4287   Dali::Vector3 *result = 0 ;
4288
4289   arg1 = jarg1;
4290   {
4291     try {
4292       result = (Dali::Vector3 *)new Dali::Vector3((float const *)arg1);
4293     } CALL_CATCH_EXCEPTION(0);
4294   }
4295
4296   jresult = (void *)result;
4297
4298
4299   return jresult;
4300 }
4301
4302
4303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_3(void * jarg1) {
4304   void * jresult ;
4305   Dali::Vector2 *arg1 = 0 ;
4306   Dali::Vector3 *result = 0 ;
4307
4308   arg1 = (Dali::Vector2 *)jarg1;
4309   if (!arg1) {
4310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4311     return 0;
4312   }
4313   {
4314     try {
4315       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector2 const &)*arg1);
4316     } CALL_CATCH_EXCEPTION(0);
4317   }
4318
4319   jresult = (void *)result;
4320   return jresult;
4321 }
4322
4323
4324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_4(void * jarg1) {
4325   void * jresult ;
4326   Dali::Vector4 *arg1 = 0 ;
4327   Dali::Vector3 *result = 0 ;
4328
4329   arg1 = (Dali::Vector4 *)jarg1;
4330   if (!arg1) {
4331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4332     return 0;
4333   }
4334   {
4335     try {
4336       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector4 const &)*arg1);
4337     } CALL_CATCH_EXCEPTION(0);
4338   }
4339
4340   jresult = (void *)result;
4341   return jresult;
4342 }
4343
4344
4345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ONE_get() {
4346   void * jresult ;
4347   Dali::Vector3 *result = 0 ;
4348
4349   result = (Dali::Vector3 *)&Dali::Vector3::ONE;
4350   jresult = (void *)result;
4351   return jresult;
4352 }
4353
4354
4355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_XAXIS_get() {
4356   void * jresult ;
4357   Dali::Vector3 *result = 0 ;
4358
4359   result = (Dali::Vector3 *)&Dali::Vector3::XAXIS;
4360   jresult = (void *)result;
4361   return jresult;
4362 }
4363
4364
4365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_YAXIS_get() {
4366   void * jresult ;
4367   Dali::Vector3 *result = 0 ;
4368
4369   result = (Dali::Vector3 *)&Dali::Vector3::YAXIS;
4370   jresult = (void *)result;
4371   return jresult;
4372 }
4373
4374
4375 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZAXIS_get() {
4376   void * jresult ;
4377   Dali::Vector3 *result = 0 ;
4378
4379   result = (Dali::Vector3 *)&Dali::Vector3::ZAXIS;
4380   jresult = (void *)result;
4381   return jresult;
4382 }
4383
4384
4385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_XAXIS_get() {
4386   void * jresult ;
4387   Dali::Vector3 *result = 0 ;
4388
4389   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_XAXIS;
4390   jresult = (void *)result;
4391   return jresult;
4392 }
4393
4394
4395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_YAXIS_get() {
4396   void * jresult ;
4397   Dali::Vector3 *result = 0 ;
4398
4399   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_YAXIS;
4400   jresult = (void *)result;
4401   return jresult;
4402 }
4403
4404
4405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_ZAXIS_get() {
4406   void * jresult ;
4407   Dali::Vector3 *result = 0 ;
4408
4409   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_ZAXIS;
4410   jresult = (void *)result;
4411   return jresult;
4412 }
4413
4414
4415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZERO_get() {
4416   void * jresult ;
4417   Dali::Vector3 *result = 0 ;
4418
4419   result = (Dali::Vector3 *)&Dali::Vector3::ZERO;
4420   jresult = (void *)result;
4421   return jresult;
4422 }
4423
4424
4425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_0(void * jarg1, float* jarg2) {
4426   void * jresult ;
4427   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4428   float *arg2 = (float *) 0 ;
4429   Dali::Vector3 *result = 0 ;
4430
4431   arg1 = (Dali::Vector3 *)jarg1;
4432   arg2 = jarg2;
4433   {
4434     try {
4435       result = (Dali::Vector3 *) &(arg1)->operator =((float const *)arg2);
4436     } CALL_CATCH_EXCEPTION(0);
4437   }
4438
4439   jresult = (void *)result;
4440
4441
4442   return jresult;
4443 }
4444
4445
4446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_1(void * jarg1, void * jarg2) {
4447   void * jresult ;
4448   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4449   Dali::Vector2 *arg2 = 0 ;
4450   Dali::Vector3 *result = 0 ;
4451
4452   arg1 = (Dali::Vector3 *)jarg1;
4453   arg2 = (Dali::Vector2 *)jarg2;
4454   if (!arg2) {
4455     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4456     return 0;
4457   }
4458   {
4459     try {
4460       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
4461     } CALL_CATCH_EXCEPTION(0);
4462   }
4463
4464   jresult = (void *)result;
4465   return jresult;
4466 }
4467
4468
4469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_2(void * jarg1, void * jarg2) {
4470   void * jresult ;
4471   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4472   Dali::Vector4 *arg2 = 0 ;
4473   Dali::Vector3 *result = 0 ;
4474
4475   arg1 = (Dali::Vector3 *)jarg1;
4476   arg2 = (Dali::Vector4 *)jarg2;
4477   if (!arg2) {
4478     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4479     return 0;
4480   }
4481   {
4482     try {
4483       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
4484     } CALL_CATCH_EXCEPTION(0);
4485   }
4486
4487   jresult = (void *)result;
4488   return jresult;
4489 }
4490
4491
4492 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Add(void * jarg1, void * jarg2) {
4493   void * jresult ;
4494   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4495   Dali::Vector3 *arg2 = 0 ;
4496   Dali::Vector3 result;
4497
4498   arg1 = (Dali::Vector3 *)jarg1;
4499   arg2 = (Dali::Vector3 *)jarg2;
4500   if (!arg2) {
4501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4502     return 0;
4503   }
4504   {
4505     try {
4506       result = ((Dali::Vector3 const *)arg1)->operator +((Dali::Vector3 const &)*arg2);
4507     } CALL_CATCH_EXCEPTION(0);
4508   }
4509
4510   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
4511   return jresult;
4512 }
4513
4514
4515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AddAssign(void * jarg1, void * jarg2) {
4516   void * jresult ;
4517   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4518   Dali::Vector3 *arg2 = 0 ;
4519   Dali::Vector3 *result = 0 ;
4520
4521   arg1 = (Dali::Vector3 *)jarg1;
4522   arg2 = (Dali::Vector3 *)jarg2;
4523   if (!arg2) {
4524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4525     return 0;
4526   }
4527   {
4528     try {
4529       result = (Dali::Vector3 *) &(arg1)->operator +=((Dali::Vector3 const &)*arg2);
4530     } CALL_CATCH_EXCEPTION(0);
4531   }
4532
4533   jresult = (void *)result;
4534   return jresult;
4535 }
4536
4537
4538 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_0(void * jarg1, void * jarg2) {
4539   void * jresult ;
4540   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4541   Dali::Vector3 *arg2 = 0 ;
4542   Dali::Vector3 result;
4543
4544   arg1 = (Dali::Vector3 *)jarg1;
4545   arg2 = (Dali::Vector3 *)jarg2;
4546   if (!arg2) {
4547     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4548     return 0;
4549   }
4550   {
4551     try {
4552       result = ((Dali::Vector3 const *)arg1)->operator -((Dali::Vector3 const &)*arg2);
4553     } CALL_CATCH_EXCEPTION(0);
4554   }
4555
4556   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
4557   return jresult;
4558 }
4559
4560
4561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_SubtractAssign(void * jarg1, void * jarg2) {
4562   void * jresult ;
4563   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4564   Dali::Vector3 *arg2 = 0 ;
4565   Dali::Vector3 *result = 0 ;
4566
4567   arg1 = (Dali::Vector3 *)jarg1;
4568   arg2 = (Dali::Vector3 *)jarg2;
4569   if (!arg2) {
4570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4571     return 0;
4572   }
4573   {
4574     try {
4575       result = (Dali::Vector3 *) &(arg1)->operator -=((Dali::Vector3 const &)*arg2);
4576     } CALL_CATCH_EXCEPTION(0);
4577   }
4578
4579   jresult = (void *)result;
4580   return jresult;
4581 }
4582
4583
4584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_0(void * jarg1, void * jarg2) {
4585   void * jresult ;
4586   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4587   Dali::Vector3 *arg2 = 0 ;
4588   Dali::Vector3 result;
4589
4590   arg1 = (Dali::Vector3 *)jarg1;
4591   arg2 = (Dali::Vector3 *)jarg2;
4592   if (!arg2) {
4593     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4594     return 0;
4595   }
4596   {
4597     try {
4598       result = ((Dali::Vector3 const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
4599     } CALL_CATCH_EXCEPTION(0);
4600   }
4601
4602   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
4603   return jresult;
4604 }
4605
4606
4607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_1(void * jarg1, float jarg2) {
4608   void * jresult ;
4609   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4610   float arg2 ;
4611   Dali::Vector3 result;
4612
4613   arg1 = (Dali::Vector3 *)jarg1;
4614   arg2 = (float)jarg2;
4615   {
4616     try {
4617       result = ((Dali::Vector3 const *)arg1)->operator *(arg2);
4618     } CALL_CATCH_EXCEPTION(0);
4619   }
4620
4621   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
4622   return jresult;
4623 }
4624
4625
4626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
4627   void * jresult ;
4628   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4629   Dali::Vector3 *arg2 = 0 ;
4630   Dali::Vector3 *result = 0 ;
4631
4632   arg1 = (Dali::Vector3 *)jarg1;
4633   arg2 = (Dali::Vector3 *)jarg2;
4634   if (!arg2) {
4635     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4636     return 0;
4637   }
4638   {
4639     try {
4640       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Vector3 const &)*arg2);
4641     } CALL_CATCH_EXCEPTION(0);
4642   }
4643
4644   jresult = (void *)result;
4645   return jresult;
4646 }
4647
4648
4649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
4650   void * jresult ;
4651   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4652   float arg2 ;
4653   Dali::Vector3 *result = 0 ;
4654
4655   arg1 = (Dali::Vector3 *)jarg1;
4656   arg2 = (float)jarg2;
4657   {
4658     try {
4659       result = (Dali::Vector3 *) &(arg1)->operator *=(arg2);
4660     } CALL_CATCH_EXCEPTION(0);
4661   }
4662
4663   jresult = (void *)result;
4664   return jresult;
4665 }
4666
4667
4668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_2(void * jarg1, void * jarg2) {
4669   void * jresult ;
4670   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4671   Dali::Quaternion *arg2 = 0 ;
4672   Dali::Vector3 *result = 0 ;
4673
4674   arg1 = (Dali::Vector3 *)jarg1;
4675   arg2 = (Dali::Quaternion *)jarg2;
4676   if (!arg2) {
4677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
4678     return 0;
4679   }
4680   {
4681     try {
4682       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
4683     } CALL_CATCH_EXCEPTION(0);
4684   }
4685
4686   jresult = (void *)result;
4687   return jresult;
4688 }
4689
4690
4691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_0(void * jarg1, void * jarg2) {
4692   void * jresult ;
4693   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4694   Dali::Vector3 *arg2 = 0 ;
4695   Dali::Vector3 result;
4696
4697   arg1 = (Dali::Vector3 *)jarg1;
4698   arg2 = (Dali::Vector3 *)jarg2;
4699   if (!arg2) {
4700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4701     return 0;
4702   }
4703   {
4704     try {
4705       result = ((Dali::Vector3 const *)arg1)->operator /((Dali::Vector3 const &)*arg2);
4706     } CALL_CATCH_EXCEPTION(0);
4707   }
4708
4709   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
4710   return jresult;
4711 }
4712
4713
4714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_1(void * jarg1, float jarg2) {
4715   void * jresult ;
4716   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4717   float arg2 ;
4718   Dali::Vector3 result;
4719
4720   arg1 = (Dali::Vector3 *)jarg1;
4721   arg2 = (float)jarg2;
4722   {
4723     try {
4724       result = ((Dali::Vector3 const *)arg1)->operator /(arg2);
4725     } CALL_CATCH_EXCEPTION(0);
4726   }
4727
4728   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
4729   return jresult;
4730 }
4731
4732
4733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
4734   void * jresult ;
4735   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4736   Dali::Vector3 *arg2 = 0 ;
4737   Dali::Vector3 *result = 0 ;
4738
4739   arg1 = (Dali::Vector3 *)jarg1;
4740   arg2 = (Dali::Vector3 *)jarg2;
4741   if (!arg2) {
4742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4743     return 0;
4744   }
4745   {
4746     try {
4747       result = (Dali::Vector3 *) &(arg1)->operator /=((Dali::Vector3 const &)*arg2);
4748     } CALL_CATCH_EXCEPTION(0);
4749   }
4750
4751   jresult = (void *)result;
4752   return jresult;
4753 }
4754
4755
4756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
4757   void * jresult ;
4758   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4759   float arg2 ;
4760   Dali::Vector3 *result = 0 ;
4761
4762   arg1 = (Dali::Vector3 *)jarg1;
4763   arg2 = (float)jarg2;
4764   {
4765     try {
4766       result = (Dali::Vector3 *) &(arg1)->operator /=(arg2);
4767     } CALL_CATCH_EXCEPTION(0);
4768   }
4769
4770   jresult = (void *)result;
4771   return jresult;
4772 }
4773
4774
4775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_1(void * jarg1) {
4776   void * jresult ;
4777   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4778   Dali::Vector3 result;
4779
4780   arg1 = (Dali::Vector3 *)jarg1;
4781   {
4782     try {
4783       result = ((Dali::Vector3 const *)arg1)->operator -();
4784     } CALL_CATCH_EXCEPTION(0);
4785   }
4786
4787   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
4788   return jresult;
4789 }
4790
4791
4792 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_EqualTo(void * jarg1, void * jarg2) {
4793   unsigned int jresult ;
4794   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4795   Dali::Vector3 *arg2 = 0 ;
4796   bool result;
4797
4798   arg1 = (Dali::Vector3 *)jarg1;
4799   arg2 = (Dali::Vector3 *)jarg2;
4800   if (!arg2) {
4801     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4802     return 0;
4803   }
4804   {
4805     try {
4806       result = (bool)((Dali::Vector3 const *)arg1)->operator ==((Dali::Vector3 const &)*arg2);
4807     } CALL_CATCH_EXCEPTION(0);
4808   }
4809
4810   jresult = result;
4811   return jresult;
4812 }
4813
4814
4815 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_NotEqualTo(void * jarg1, void * jarg2) {
4816   unsigned int jresult ;
4817   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4818   Dali::Vector3 *arg2 = 0 ;
4819   bool result;
4820
4821   arg1 = (Dali::Vector3 *)jarg1;
4822   arg2 = (Dali::Vector3 *)jarg2;
4823   if (!arg2) {
4824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4825     return 0;
4826   }
4827   {
4828     try {
4829       result = (bool)((Dali::Vector3 const *)arg1)->operator !=((Dali::Vector3 const &)*arg2);
4830     } CALL_CATCH_EXCEPTION(0);
4831   }
4832
4833   jresult = result;
4834   return jresult;
4835 }
4836
4837
4838 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
4839   float jresult ;
4840   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4841   unsigned int arg2 ;
4842   float *result = 0 ;
4843
4844   arg1 = (Dali::Vector3 *)jarg1;
4845   arg2 = (unsigned int)jarg2;
4846   {
4847     try {
4848       result = (float *) &((Dali::Vector3 const *)arg1)->operator [](arg2);
4849     } CALL_CATCH_EXCEPTION(0);
4850   }
4851
4852   jresult = *result;
4853   return jresult;
4854 }
4855
4856
4857 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Dot(void * jarg1, void * jarg2) {
4858   float jresult ;
4859   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4860   Dali::Vector3 *arg2 = 0 ;
4861   float result;
4862
4863   arg1 = (Dali::Vector3 *)jarg1;
4864   arg2 = (Dali::Vector3 *)jarg2;
4865   if (!arg2) {
4866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4867     return 0;
4868   }
4869   {
4870     try {
4871       result = (float)((Dali::Vector3 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
4872     } CALL_CATCH_EXCEPTION(0);
4873   }
4874
4875   jresult = result;
4876   return jresult;
4877 }
4878
4879
4880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Cross(void * jarg1, void * jarg2) {
4881   void * jresult ;
4882   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4883   Dali::Vector3 *arg2 = 0 ;
4884   Dali::Vector3 result;
4885
4886   arg1 = (Dali::Vector3 *)jarg1;
4887   arg2 = (Dali::Vector3 *)jarg2;
4888   if (!arg2) {
4889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4890     return 0;
4891   }
4892   {
4893     try {
4894       result = ((Dali::Vector3 const *)arg1)->Cross((Dali::Vector3 const &)*arg2);
4895     } CALL_CATCH_EXCEPTION(0);
4896   }
4897
4898   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
4899   return jresult;
4900 }
4901
4902
4903 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Length(void * jarg1) {
4904   float jresult ;
4905   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4906   float result;
4907
4908   arg1 = (Dali::Vector3 *)jarg1;
4909   {
4910     try {
4911       result = (float)((Dali::Vector3 const *)arg1)->Length();
4912     } CALL_CATCH_EXCEPTION(0);
4913   }
4914
4915   jresult = result;
4916   return jresult;
4917 }
4918
4919
4920 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_LengthSquared(void * jarg1) {
4921   float jresult ;
4922   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4923   float result;
4924
4925   arg1 = (Dali::Vector3 *)jarg1;
4926   {
4927     try {
4928       result = (float)((Dali::Vector3 const *)arg1)->LengthSquared();
4929     } CALL_CATCH_EXCEPTION(0);
4930   }
4931
4932   jresult = result;
4933   return jresult;
4934 }
4935
4936
4937 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Normalize(void * jarg1) {
4938   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4939
4940   arg1 = (Dali::Vector3 *)jarg1;
4941   {
4942     try {
4943       (arg1)->Normalize();
4944     } CALL_CATCH_EXCEPTION();
4945   }
4946
4947 }
4948
4949
4950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Clamp(void * jarg1, void * jarg2, void * jarg3) {
4951   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4952   Dali::Vector3 *arg2 = 0 ;
4953   Dali::Vector3 *arg3 = 0 ;
4954
4955   arg1 = (Dali::Vector3 *)jarg1;
4956   arg2 = (Dali::Vector3 *)jarg2;
4957   if (!arg2) {
4958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4959     return ;
4960   }
4961   arg3 = (Dali::Vector3 *)jarg3;
4962   if (!arg3) {
4963     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4964     return ;
4965   }
4966   {
4967     try {
4968       (arg1)->Clamp((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3);
4969     } CALL_CATCH_EXCEPTION();
4970   }
4971
4972 }
4973
4974
4975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AsFloat__SWIG_0(void * jarg1) {
4976   void * jresult ;
4977   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4978   float *result = 0 ;
4979
4980   arg1 = (Dali::Vector3 *)jarg1;
4981   {
4982     try {
4983       result = (float *)((Dali::Vector3 const *)arg1)->AsFloat();
4984     } CALL_CATCH_EXCEPTION(0);
4985   }
4986
4987   jresult = (void *)result;
4988   return jresult;
4989 }
4990
4991
4992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorXY__SWIG_0(void * jarg1) {
4993   void * jresult ;
4994   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
4995   Dali::Vector2 *result = 0 ;
4996
4997   arg1 = (Dali::Vector3 *)jarg1;
4998   {
4999     try {
5000       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorXY();
5001     } CALL_CATCH_EXCEPTION(0);
5002   }
5003
5004   jresult = (void *)result;
5005   return jresult;
5006 }
5007
5008
5009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorYZ__SWIG_0(void * jarg1) {
5010   void * jresult ;
5011   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5012   Dali::Vector2 *result = 0 ;
5013
5014   arg1 = (Dali::Vector3 *)jarg1;
5015   {
5016     try {
5017       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorYZ();
5018     } CALL_CATCH_EXCEPTION(0);
5019   }
5020
5021   jresult = (void *)result;
5022   return jresult;
5023 }
5024
5025
5026 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_X_set(void * jarg1, float jarg2) {
5027   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5028   float arg2 ;
5029
5030   arg1 = (Dali::Vector3 *)jarg1;
5031   arg2 = (float)jarg2;
5032   if (arg1) (arg1)->x = arg2;
5033 }
5034
5035
5036 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_X_get(void * jarg1) {
5037   float jresult ;
5038   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5039   float result;
5040
5041   arg1 = (Dali::Vector3 *)jarg1;
5042   result = (float) ((arg1)->x);
5043   jresult = result;
5044   return jresult;
5045 }
5046
5047
5048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Width_set(void * jarg1, float jarg2) {
5049   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5050   float arg2 ;
5051
5052   arg1 = (Dali::Vector3 *)jarg1;
5053   arg2 = (float)jarg2;
5054   if (arg1) (arg1)->width = arg2;
5055 }
5056
5057
5058 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Width_get(void * jarg1) {
5059   float jresult ;
5060   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5061   float result;
5062
5063   arg1 = (Dali::Vector3 *)jarg1;
5064   result = (float) ((arg1)->width);
5065   jresult = result;
5066   return jresult;
5067 }
5068
5069
5070 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_r_set(void * jarg1, float jarg2) {
5071   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5072   float arg2 ;
5073
5074   arg1 = (Dali::Vector3 *)jarg1;
5075   arg2 = (float)jarg2;
5076   if (arg1) (arg1)->r = arg2;
5077 }
5078
5079
5080 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_r_get(void * jarg1) {
5081   float jresult ;
5082   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5083   float result;
5084
5085   arg1 = (Dali::Vector3 *)jarg1;
5086   result = (float) ((arg1)->r);
5087   jresult = result;
5088   return jresult;
5089 }
5090
5091
5092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Y_set(void * jarg1, float jarg2) {
5093   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5094   float arg2 ;
5095
5096   arg1 = (Dali::Vector3 *)jarg1;
5097   arg2 = (float)jarg2;
5098   if (arg1) (arg1)->y = arg2;
5099 }
5100
5101
5102 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Y_get(void * jarg1) {
5103   float jresult ;
5104   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5105   float result;
5106
5107   arg1 = (Dali::Vector3 *)jarg1;
5108   result = (float) ((arg1)->y);
5109   jresult = result;
5110   return jresult;
5111 }
5112
5113
5114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Height_set(void * jarg1, float jarg2) {
5115   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5116   float arg2 ;
5117
5118   arg1 = (Dali::Vector3 *)jarg1;
5119   arg2 = (float)jarg2;
5120   if (arg1) (arg1)->height = arg2;
5121 }
5122
5123
5124 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Height_get(void * jarg1) {
5125   float jresult ;
5126   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5127   float result;
5128
5129   arg1 = (Dali::Vector3 *)jarg1;
5130   result = (float) ((arg1)->height);
5131   jresult = result;
5132   return jresult;
5133 }
5134
5135
5136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_g_set(void * jarg1, float jarg2) {
5137   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5138   float arg2 ;
5139
5140   arg1 = (Dali::Vector3 *)jarg1;
5141   arg2 = (float)jarg2;
5142   if (arg1) (arg1)->g = arg2;
5143 }
5144
5145
5146 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_g_get(void * jarg1) {
5147   float jresult ;
5148   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5149   float result;
5150
5151   arg1 = (Dali::Vector3 *)jarg1;
5152   result = (float) ((arg1)->g);
5153   jresult = result;
5154   return jresult;
5155 }
5156
5157
5158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Z_set(void * jarg1, float jarg2) {
5159   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5160   float arg2 ;
5161
5162   arg1 = (Dali::Vector3 *)jarg1;
5163   arg2 = (float)jarg2;
5164   if (arg1) (arg1)->z = arg2;
5165 }
5166
5167
5168 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Z_get(void * jarg1) {
5169   float jresult ;
5170   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5171   float result;
5172
5173   arg1 = (Dali::Vector3 *)jarg1;
5174   result = (float) ((arg1)->z);
5175   jresult = result;
5176   return jresult;
5177 }
5178
5179
5180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Depth_set(void * jarg1, float jarg2) {
5181   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5182   float arg2 ;
5183
5184   arg1 = (Dali::Vector3 *)jarg1;
5185   arg2 = (float)jarg2;
5186   if (arg1) (arg1)->depth = arg2;
5187 }
5188
5189
5190 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Depth_get(void * jarg1) {
5191   float jresult ;
5192   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5193   float result;
5194
5195   arg1 = (Dali::Vector3 *)jarg1;
5196   result = (float) ((arg1)->depth);
5197   jresult = result;
5198   return jresult;
5199 }
5200
5201
5202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_b_set(void * jarg1, float jarg2) {
5203   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5204   float arg2 ;
5205
5206   arg1 = (Dali::Vector3 *)jarg1;
5207   arg2 = (float)jarg2;
5208   if (arg1) (arg1)->b = arg2;
5209 }
5210
5211
5212 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_b_get(void * jarg1) {
5213   float jresult ;
5214   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5215   float result;
5216
5217   arg1 = (Dali::Vector3 *)jarg1;
5218   result = (float) ((arg1)->b);
5219   jresult = result;
5220   return jresult;
5221 }
5222
5223
5224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector3(void * jarg1) {
5225   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5226
5227   arg1 = (Dali::Vector3 *)jarg1;
5228   {
5229     try {
5230       delete arg1;
5231     } CALL_CATCH_EXCEPTION();
5232   }
5233
5234 }
5235
5236
5237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_1(void * jarg1, void * jarg2) {
5238   void * jresult ;
5239   Dali::Vector3 *arg1 = 0 ;
5240   Dali::Vector3 *arg2 = 0 ;
5241   Dali::Vector3 result;
5242
5243   arg1 = (Dali::Vector3 *)jarg1;
5244   if (!arg1) {
5245     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5246     return 0;
5247   }
5248   arg2 = (Dali::Vector3 *)jarg2;
5249   if (!arg2) {
5250     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5251     return 0;
5252   }
5253   {
5254     try {
5255       result = Dali::Min((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
5256     } CALL_CATCH_EXCEPTION(0);
5257   }
5258
5259   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5260   return jresult;
5261 }
5262
5263
5264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_1(void * jarg1, void * jarg2) {
5265   void * jresult ;
5266   Dali::Vector3 *arg1 = 0 ;
5267   Dali::Vector3 *arg2 = 0 ;
5268   Dali::Vector3 result;
5269
5270   arg1 = (Dali::Vector3 *)jarg1;
5271   if (!arg1) {
5272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5273     return 0;
5274   }
5275   arg2 = (Dali::Vector3 *)jarg2;
5276   if (!arg2) {
5277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5278     return 0;
5279   }
5280   {
5281     try {
5282       result = Dali::Max((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
5283     } CALL_CATCH_EXCEPTION(0);
5284   }
5285
5286   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5287   return jresult;
5288 }
5289
5290
5291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
5292   void * jresult ;
5293   Dali::Vector3 *arg1 = 0 ;
5294   float *arg2 = 0 ;
5295   float *arg3 = 0 ;
5296   float temp2 ;
5297   float temp3 ;
5298   Dali::Vector3 result;
5299
5300   arg1 = (Dali::Vector3 *)jarg1;
5301   if (!arg1) {
5302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5303     return 0;
5304   }
5305   temp2 = (float)jarg2;
5306   arg2 = &temp2;
5307   temp3 = (float)jarg3;
5308   arg3 = &temp3;
5309   {
5310     try {
5311       result = Dali::Clamp((Dali::Vector3 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
5312     } CALL_CATCH_EXCEPTION(0);
5313   }
5314
5315   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5316   return jresult;
5317 }
5318
5319
5320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_0() {
5321   void * jresult ;
5322   Dali::Vector4 *result = 0 ;
5323
5324   {
5325     try {
5326       result = (Dali::Vector4 *)new Dali::Vector4();
5327     } CALL_CATCH_EXCEPTION(0);
5328   }
5329
5330   jresult = (void *)result;
5331   return jresult;
5332 }
5333
5334
5335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
5336   void * jresult ;
5337   float arg1 ;
5338   float arg2 ;
5339   float arg3 ;
5340   float arg4 ;
5341   Dali::Vector4 *result = 0 ;
5342
5343   arg1 = (float)jarg1;
5344   arg2 = (float)jarg2;
5345   arg3 = (float)jarg3;
5346   arg4 = (float)jarg4;
5347   {
5348     try {
5349       result = (Dali::Vector4 *)new Dali::Vector4(arg1,arg2,arg3,arg4);
5350     } CALL_CATCH_EXCEPTION(0);
5351   }
5352
5353   jresult = (void *)result;
5354   return jresult;
5355 }
5356
5357
5358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_2(float* jarg1) {
5359   void * jresult ;
5360   float *arg1 = (float *) 0 ;
5361   Dali::Vector4 *result = 0 ;
5362
5363   arg1 = jarg1;
5364   {
5365     try {
5366       result = (Dali::Vector4 *)new Dali::Vector4((float const *)arg1);
5367     } CALL_CATCH_EXCEPTION(0);
5368   }
5369
5370   jresult = (void *)result;
5371
5372
5373   return jresult;
5374 }
5375
5376
5377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_3(void * jarg1) {
5378   void * jresult ;
5379   Dali::Vector2 *arg1 = 0 ;
5380   Dali::Vector4 *result = 0 ;
5381
5382   arg1 = (Dali::Vector2 *)jarg1;
5383   if (!arg1) {
5384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5385     return 0;
5386   }
5387   {
5388     try {
5389       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector2 const &)*arg1);
5390     } CALL_CATCH_EXCEPTION(0);
5391   }
5392
5393   jresult = (void *)result;
5394   return jresult;
5395 }
5396
5397
5398 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_4(void * jarg1) {
5399   void * jresult ;
5400   Dali::Vector3 *arg1 = 0 ;
5401   Dali::Vector4 *result = 0 ;
5402
5403   arg1 = (Dali::Vector3 *)jarg1;
5404   if (!arg1) {
5405     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5406     return 0;
5407   }
5408   {
5409     try {
5410       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector3 const &)*arg1);
5411     } CALL_CATCH_EXCEPTION(0);
5412   }
5413
5414   jresult = (void *)result;
5415   return jresult;
5416 }
5417
5418
5419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ONE_get() {
5420   void * jresult ;
5421   Dali::Vector4 *result = 0 ;
5422
5423   result = (Dali::Vector4 *)&Dali::Vector4::ONE;
5424   jresult = (void *)result;
5425   return jresult;
5426 }
5427
5428
5429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_XAXIS_get() {
5430   void * jresult ;
5431   Dali::Vector4 *result = 0 ;
5432
5433   result = (Dali::Vector4 *)&Dali::Vector4::XAXIS;
5434   jresult = (void *)result;
5435   return jresult;
5436 }
5437
5438
5439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_YAXIS_get() {
5440   void * jresult ;
5441   Dali::Vector4 *result = 0 ;
5442
5443   result = (Dali::Vector4 *)&Dali::Vector4::YAXIS;
5444   jresult = (void *)result;
5445   return jresult;
5446 }
5447
5448
5449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZAXIS_get() {
5450   void * jresult ;
5451   Dali::Vector4 *result = 0 ;
5452
5453   result = (Dali::Vector4 *)&Dali::Vector4::ZAXIS;
5454   jresult = (void *)result;
5455   return jresult;
5456 }
5457
5458
5459 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZERO_get() {
5460   void * jresult ;
5461   Dali::Vector4 *result = 0 ;
5462
5463   result = (Dali::Vector4 *)&Dali::Vector4::ZERO;
5464   jresult = (void *)result;
5465   return jresult;
5466 }
5467
5468
5469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_0(void * jarg1, float* jarg2) {
5470   void * jresult ;
5471   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5472   float *arg2 = (float *) 0 ;
5473   Dali::Vector4 *result = 0 ;
5474
5475   arg1 = (Dali::Vector4 *)jarg1;
5476   arg2 = jarg2;
5477   {
5478     try {
5479       result = (Dali::Vector4 *) &(arg1)->operator =((float const *)arg2);
5480     } CALL_CATCH_EXCEPTION(0);
5481   }
5482
5483   jresult = (void *)result;
5484
5485
5486   return jresult;
5487 }
5488
5489
5490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_1(void * jarg1, void * jarg2) {
5491   void * jresult ;
5492   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5493   Dali::Vector2 *arg2 = 0 ;
5494   Dali::Vector4 *result = 0 ;
5495
5496   arg1 = (Dali::Vector4 *)jarg1;
5497   arg2 = (Dali::Vector2 *)jarg2;
5498   if (!arg2) {
5499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5500     return 0;
5501   }
5502   {
5503     try {
5504       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
5505     } CALL_CATCH_EXCEPTION(0);
5506   }
5507
5508   jresult = (void *)result;
5509   return jresult;
5510 }
5511
5512
5513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_2(void * jarg1, void * jarg2) {
5514   void * jresult ;
5515   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5516   Dali::Vector3 *arg2 = 0 ;
5517   Dali::Vector4 *result = 0 ;
5518
5519   arg1 = (Dali::Vector4 *)jarg1;
5520   arg2 = (Dali::Vector3 *)jarg2;
5521   if (!arg2) {
5522     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5523     return 0;
5524   }
5525   {
5526     try {
5527       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
5528     } CALL_CATCH_EXCEPTION(0);
5529   }
5530
5531   jresult = (void *)result;
5532   return jresult;
5533 }
5534
5535
5536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Add(void * jarg1, void * jarg2) {
5537   void * jresult ;
5538   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5539   Dali::Vector4 *arg2 = 0 ;
5540   Dali::Vector4 result;
5541
5542   arg1 = (Dali::Vector4 *)jarg1;
5543   arg2 = (Dali::Vector4 *)jarg2;
5544   if (!arg2) {
5545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5546     return 0;
5547   }
5548   {
5549     try {
5550       result = ((Dali::Vector4 const *)arg1)->operator +((Dali::Vector4 const &)*arg2);
5551     } CALL_CATCH_EXCEPTION(0);
5552   }
5553
5554   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
5555   return jresult;
5556 }
5557
5558
5559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AddAssign(void * jarg1, void * jarg2) {
5560   void * jresult ;
5561   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5562   Dali::Vector4 *arg2 = 0 ;
5563   Dali::Vector4 *result = 0 ;
5564
5565   arg1 = (Dali::Vector4 *)jarg1;
5566   arg2 = (Dali::Vector4 *)jarg2;
5567   if (!arg2) {
5568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5569     return 0;
5570   }
5571   {
5572     try {
5573       result = (Dali::Vector4 *) &(arg1)->operator +=((Dali::Vector4 const &)*arg2);
5574     } CALL_CATCH_EXCEPTION(0);
5575   }
5576
5577   jresult = (void *)result;
5578   return jresult;
5579 }
5580
5581
5582 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_0(void * jarg1, void * jarg2) {
5583   void * jresult ;
5584   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5585   Dali::Vector4 *arg2 = 0 ;
5586   Dali::Vector4 result;
5587
5588   arg1 = (Dali::Vector4 *)jarg1;
5589   arg2 = (Dali::Vector4 *)jarg2;
5590   if (!arg2) {
5591     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5592     return 0;
5593   }
5594   {
5595     try {
5596       result = ((Dali::Vector4 const *)arg1)->operator -((Dali::Vector4 const &)*arg2);
5597     } CALL_CATCH_EXCEPTION(0);
5598   }
5599
5600   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
5601   return jresult;
5602 }
5603
5604
5605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_SubtractAssign(void * jarg1, void * jarg2) {
5606   void * jresult ;
5607   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5608   Dali::Vector4 *arg2 = 0 ;
5609   Dali::Vector4 *result = 0 ;
5610
5611   arg1 = (Dali::Vector4 *)jarg1;
5612   arg2 = (Dali::Vector4 *)jarg2;
5613   if (!arg2) {
5614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5615     return 0;
5616   }
5617   {
5618     try {
5619       result = (Dali::Vector4 *) &(arg1)->operator -=((Dali::Vector4 const &)*arg2);
5620     } CALL_CATCH_EXCEPTION(0);
5621   }
5622
5623   jresult = (void *)result;
5624   return jresult;
5625 }
5626
5627
5628 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_0(void * jarg1, void * jarg2) {
5629   void * jresult ;
5630   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5631   Dali::Vector4 *arg2 = 0 ;
5632   Dali::Vector4 result;
5633
5634   arg1 = (Dali::Vector4 *)jarg1;
5635   arg2 = (Dali::Vector4 *)jarg2;
5636   if (!arg2) {
5637     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5638     return 0;
5639   }
5640   {
5641     try {
5642       result = ((Dali::Vector4 const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
5643     } CALL_CATCH_EXCEPTION(0);
5644   }
5645
5646   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
5647   return jresult;
5648 }
5649
5650
5651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_1(void * jarg1, float jarg2) {
5652   void * jresult ;
5653   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5654   float arg2 ;
5655   Dali::Vector4 result;
5656
5657   arg1 = (Dali::Vector4 *)jarg1;
5658   arg2 = (float)jarg2;
5659   {
5660     try {
5661       result = ((Dali::Vector4 const *)arg1)->operator *(arg2);
5662     } CALL_CATCH_EXCEPTION(0);
5663   }
5664
5665   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
5666   return jresult;
5667 }
5668
5669
5670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
5671   void * jresult ;
5672   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5673   Dali::Vector4 *arg2 = 0 ;
5674   Dali::Vector4 *result = 0 ;
5675
5676   arg1 = (Dali::Vector4 *)jarg1;
5677   arg2 = (Dali::Vector4 *)jarg2;
5678   if (!arg2) {
5679     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5680     return 0;
5681   }
5682   {
5683     try {
5684       result = (Dali::Vector4 *) &(arg1)->operator *=((Dali::Vector4 const &)*arg2);
5685     } CALL_CATCH_EXCEPTION(0);
5686   }
5687
5688   jresult = (void *)result;
5689   return jresult;
5690 }
5691
5692
5693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
5694   void * jresult ;
5695   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5696   float arg2 ;
5697   Dali::Vector4 *result = 0 ;
5698
5699   arg1 = (Dali::Vector4 *)jarg1;
5700   arg2 = (float)jarg2;
5701   {
5702     try {
5703       result = (Dali::Vector4 *) &(arg1)->operator *=(arg2);
5704     } CALL_CATCH_EXCEPTION(0);
5705   }
5706
5707   jresult = (void *)result;
5708   return jresult;
5709 }
5710
5711
5712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_0(void * jarg1, void * jarg2) {
5713   void * jresult ;
5714   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5715   Dali::Vector4 *arg2 = 0 ;
5716   Dali::Vector4 result;
5717
5718   arg1 = (Dali::Vector4 *)jarg1;
5719   arg2 = (Dali::Vector4 *)jarg2;
5720   if (!arg2) {
5721     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5722     return 0;
5723   }
5724   {
5725     try {
5726       result = ((Dali::Vector4 const *)arg1)->operator /((Dali::Vector4 const &)*arg2);
5727     } CALL_CATCH_EXCEPTION(0);
5728   }
5729
5730   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
5731   return jresult;
5732 }
5733
5734
5735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_1(void * jarg1, float jarg2) {
5736   void * jresult ;
5737   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5738   float arg2 ;
5739   Dali::Vector4 result;
5740
5741   arg1 = (Dali::Vector4 *)jarg1;
5742   arg2 = (float)jarg2;
5743   {
5744     try {
5745       result = ((Dali::Vector4 const *)arg1)->operator /(arg2);
5746     } CALL_CATCH_EXCEPTION(0);
5747   }
5748
5749   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
5750   return jresult;
5751 }
5752
5753
5754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
5755   void * jresult ;
5756   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5757   Dali::Vector4 *arg2 = 0 ;
5758   Dali::Vector4 *result = 0 ;
5759
5760   arg1 = (Dali::Vector4 *)jarg1;
5761   arg2 = (Dali::Vector4 *)jarg2;
5762   if (!arg2) {
5763     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5764     return 0;
5765   }
5766   {
5767     try {
5768       result = (Dali::Vector4 *) &(arg1)->operator /=((Dali::Vector4 const &)*arg2);
5769     } CALL_CATCH_EXCEPTION(0);
5770   }
5771
5772   jresult = (void *)result;
5773   return jresult;
5774 }
5775
5776
5777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
5778   void * jresult ;
5779   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5780   float arg2 ;
5781   Dali::Vector4 *result = 0 ;
5782
5783   arg1 = (Dali::Vector4 *)jarg1;
5784   arg2 = (float)jarg2;
5785   {
5786     try {
5787       result = (Dali::Vector4 *) &(arg1)->operator /=(arg2);
5788     } CALL_CATCH_EXCEPTION(0);
5789   }
5790
5791   jresult = (void *)result;
5792   return jresult;
5793 }
5794
5795
5796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_1(void * jarg1) {
5797   void * jresult ;
5798   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5799   Dali::Vector4 result;
5800
5801   arg1 = (Dali::Vector4 *)jarg1;
5802   {
5803     try {
5804       result = ((Dali::Vector4 const *)arg1)->operator -();
5805     } CALL_CATCH_EXCEPTION(0);
5806   }
5807
5808   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
5809   return jresult;
5810 }
5811
5812
5813 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_EqualTo(void * jarg1, void * jarg2) {
5814   unsigned int jresult ;
5815   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5816   Dali::Vector4 *arg2 = 0 ;
5817   bool result;
5818
5819   arg1 = (Dali::Vector4 *)jarg1;
5820   arg2 = (Dali::Vector4 *)jarg2;
5821   if (!arg2) {
5822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5823     return 0;
5824   }
5825   {
5826     try {
5827       result = (bool)((Dali::Vector4 const *)arg1)->operator ==((Dali::Vector4 const &)*arg2);
5828     } CALL_CATCH_EXCEPTION(0);
5829   }
5830
5831   jresult = result;
5832   return jresult;
5833 }
5834
5835
5836 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_NotEqualTo(void * jarg1, void * jarg2) {
5837   unsigned int jresult ;
5838   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5839   Dali::Vector4 *arg2 = 0 ;
5840   bool result;
5841
5842   arg1 = (Dali::Vector4 *)jarg1;
5843   arg2 = (Dali::Vector4 *)jarg2;
5844   if (!arg2) {
5845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5846     return 0;
5847   }
5848   {
5849     try {
5850       result = (bool)((Dali::Vector4 const *)arg1)->operator !=((Dali::Vector4 const &)*arg2);
5851     } CALL_CATCH_EXCEPTION(0);
5852   }
5853
5854   jresult = result;
5855   return jresult;
5856 }
5857
5858
5859 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
5860   float jresult ;
5861   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5862   unsigned int arg2 ;
5863   float *result = 0 ;
5864
5865   arg1 = (Dali::Vector4 *)jarg1;
5866   arg2 = (unsigned int)jarg2;
5867   {
5868     try {
5869       result = (float *) &((Dali::Vector4 const *)arg1)->operator [](arg2);
5870     } CALL_CATCH_EXCEPTION(0);
5871   }
5872
5873   jresult = *result;
5874   return jresult;
5875 }
5876
5877
5878 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_0(void * jarg1, void * jarg2) {
5879   float jresult ;
5880   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5881   Dali::Vector3 *arg2 = 0 ;
5882   float result;
5883
5884   arg1 = (Dali::Vector4 *)jarg1;
5885   arg2 = (Dali::Vector3 *)jarg2;
5886   if (!arg2) {
5887     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5888     return 0;
5889   }
5890   {
5891     try {
5892       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
5893     } CALL_CATCH_EXCEPTION(0);
5894   }
5895
5896   jresult = result;
5897   return jresult;
5898 }
5899
5900
5901 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_1(void * jarg1, void * jarg2) {
5902   float jresult ;
5903   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5904   Dali::Vector4 *arg2 = 0 ;
5905   float result;
5906
5907   arg1 = (Dali::Vector4 *)jarg1;
5908   arg2 = (Dali::Vector4 *)jarg2;
5909   if (!arg2) {
5910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5911     return 0;
5912   }
5913   {
5914     try {
5915       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector4 const &)*arg2);
5916     } CALL_CATCH_EXCEPTION(0);
5917   }
5918
5919   jresult = result;
5920   return jresult;
5921 }
5922
5923
5924 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot4(void * jarg1, void * jarg2) {
5925   float jresult ;
5926   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5927   Dali::Vector4 *arg2 = 0 ;
5928   float result;
5929
5930   arg1 = (Dali::Vector4 *)jarg1;
5931   arg2 = (Dali::Vector4 *)jarg2;
5932   if (!arg2) {
5933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5934     return 0;
5935   }
5936   {
5937     try {
5938       result = (float)((Dali::Vector4 const *)arg1)->Dot4((Dali::Vector4 const &)*arg2);
5939     } CALL_CATCH_EXCEPTION(0);
5940   }
5941
5942   jresult = result;
5943   return jresult;
5944 }
5945
5946
5947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Cross(void * jarg1, void * jarg2) {
5948   void * jresult ;
5949   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5950   Dali::Vector4 *arg2 = 0 ;
5951   Dali::Vector4 result;
5952
5953   arg1 = (Dali::Vector4 *)jarg1;
5954   arg2 = (Dali::Vector4 *)jarg2;
5955   if (!arg2) {
5956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5957     return 0;
5958   }
5959   {
5960     try {
5961       result = ((Dali::Vector4 const *)arg1)->Cross((Dali::Vector4 const &)*arg2);
5962     } CALL_CATCH_EXCEPTION(0);
5963   }
5964
5965   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
5966   return jresult;
5967 }
5968
5969
5970 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Length(void * jarg1) {
5971   float jresult ;
5972   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5973   float result;
5974
5975   arg1 = (Dali::Vector4 *)jarg1;
5976   {
5977     try {
5978       result = (float)((Dali::Vector4 const *)arg1)->Length();
5979     } CALL_CATCH_EXCEPTION(0);
5980   }
5981
5982   jresult = result;
5983   return jresult;
5984 }
5985
5986
5987 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_LengthSquared(void * jarg1) {
5988   float jresult ;
5989   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
5990   float result;
5991
5992   arg1 = (Dali::Vector4 *)jarg1;
5993   {
5994     try {
5995       result = (float)((Dali::Vector4 const *)arg1)->LengthSquared();
5996     } CALL_CATCH_EXCEPTION(0);
5997   }
5998
5999   jresult = result;
6000   return jresult;
6001 }
6002
6003
6004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Normalize(void * jarg1) {
6005   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6006
6007   arg1 = (Dali::Vector4 *)jarg1;
6008   {
6009     try {
6010       (arg1)->Normalize();
6011     } CALL_CATCH_EXCEPTION();
6012   }
6013
6014 }
6015
6016
6017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Clamp(void * jarg1, void * jarg2, void * jarg3) {
6018   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6019   Dali::Vector4 *arg2 = 0 ;
6020   Dali::Vector4 *arg3 = 0 ;
6021
6022   arg1 = (Dali::Vector4 *)jarg1;
6023   arg2 = (Dali::Vector4 *)jarg2;
6024   if (!arg2) {
6025     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6026     return ;
6027   }
6028   arg3 = (Dali::Vector4 *)jarg3;
6029   if (!arg3) {
6030     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6031     return ;
6032   }
6033   {
6034     try {
6035       (arg1)->Clamp((Dali::Vector4 const &)*arg2,(Dali::Vector4 const &)*arg3);
6036     } CALL_CATCH_EXCEPTION();
6037   }
6038
6039 }
6040
6041
6042 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AsFloat__SWIG_0(void * jarg1) {
6043   void * jresult ;
6044   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6045   float *result = 0 ;
6046
6047   arg1 = (Dali::Vector4 *)jarg1;
6048   {
6049     try {
6050       result = (float *)((Dali::Vector4 const *)arg1)->AsFloat();
6051     } CALL_CATCH_EXCEPTION(0);
6052   }
6053
6054   jresult = (void *)result;
6055   return jresult;
6056 }
6057
6058
6059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_X_set(void * jarg1, float jarg2) {
6060   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6061   float arg2 ;
6062
6063   arg1 = (Dali::Vector4 *)jarg1;
6064   arg2 = (float)jarg2;
6065   if (arg1) (arg1)->x = arg2;
6066 }
6067
6068
6069 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_X_get(void * jarg1) {
6070   float jresult ;
6071   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6072   float result;
6073
6074   arg1 = (Dali::Vector4 *)jarg1;
6075   result = (float) ((arg1)->x);
6076   jresult = result;
6077   return jresult;
6078 }
6079
6080
6081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_r_set(void * jarg1, float jarg2) {
6082   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6083   float arg2 ;
6084
6085   arg1 = (Dali::Vector4 *)jarg1;
6086   arg2 = (float)jarg2;
6087   if (arg1) (arg1)->r = arg2;
6088 }
6089
6090
6091 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_r_get(void * jarg1) {
6092   float jresult ;
6093   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6094   float result;
6095
6096   arg1 = (Dali::Vector4 *)jarg1;
6097   result = (float) ((arg1)->r);
6098   jresult = result;
6099   return jresult;
6100 }
6101
6102
6103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_s_set(void * jarg1, float jarg2) {
6104   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6105   float arg2 ;
6106
6107   arg1 = (Dali::Vector4 *)jarg1;
6108   arg2 = (float)jarg2;
6109   if (arg1) (arg1)->s = arg2;
6110 }
6111
6112
6113 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_s_get(void * jarg1) {
6114   float jresult ;
6115   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6116   float result;
6117
6118   arg1 = (Dali::Vector4 *)jarg1;
6119   result = (float) ((arg1)->s);
6120   jresult = result;
6121   return jresult;
6122 }
6123
6124
6125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Y_set(void * jarg1, float jarg2) {
6126   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6127   float arg2 ;
6128
6129   arg1 = (Dali::Vector4 *)jarg1;
6130   arg2 = (float)jarg2;
6131   if (arg1) (arg1)->y = arg2;
6132 }
6133
6134
6135 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Y_get(void * jarg1) {
6136   float jresult ;
6137   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6138   float result;
6139
6140   arg1 = (Dali::Vector4 *)jarg1;
6141   result = (float) ((arg1)->y);
6142   jresult = result;
6143   return jresult;
6144 }
6145
6146
6147 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_g_set(void * jarg1, float jarg2) {
6148   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6149   float arg2 ;
6150
6151   arg1 = (Dali::Vector4 *)jarg1;
6152   arg2 = (float)jarg2;
6153   if (arg1) (arg1)->g = arg2;
6154 }
6155
6156
6157 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_g_get(void * jarg1) {
6158   float jresult ;
6159   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6160   float result;
6161
6162   arg1 = (Dali::Vector4 *)jarg1;
6163   result = (float) ((arg1)->g);
6164   jresult = result;
6165   return jresult;
6166 }
6167
6168
6169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_t_set(void * jarg1, float jarg2) {
6170   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6171   float arg2 ;
6172
6173   arg1 = (Dali::Vector4 *)jarg1;
6174   arg2 = (float)jarg2;
6175   if (arg1) (arg1)->t = arg2;
6176 }
6177
6178
6179 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_t_get(void * jarg1) {
6180   float jresult ;
6181   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6182   float result;
6183
6184   arg1 = (Dali::Vector4 *)jarg1;
6185   result = (float) ((arg1)->t);
6186   jresult = result;
6187   return jresult;
6188 }
6189
6190
6191 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Z_set(void * jarg1, float jarg2) {
6192   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6193   float arg2 ;
6194
6195   arg1 = (Dali::Vector4 *)jarg1;
6196   arg2 = (float)jarg2;
6197   if (arg1) (arg1)->z = arg2;
6198 }
6199
6200
6201 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Z_get(void * jarg1) {
6202   float jresult ;
6203   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6204   float result;
6205
6206   arg1 = (Dali::Vector4 *)jarg1;
6207   result = (float) ((arg1)->z);
6208   jresult = result;
6209   return jresult;
6210 }
6211
6212
6213 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_b_set(void * jarg1, float jarg2) {
6214   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6215   float arg2 ;
6216
6217   arg1 = (Dali::Vector4 *)jarg1;
6218   arg2 = (float)jarg2;
6219   if (arg1) (arg1)->b = arg2;
6220 }
6221
6222
6223 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_b_get(void * jarg1) {
6224   float jresult ;
6225   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6226   float result;
6227
6228   arg1 = (Dali::Vector4 *)jarg1;
6229   result = (float) ((arg1)->b);
6230   jresult = result;
6231   return jresult;
6232 }
6233
6234
6235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_p_set(void * jarg1, float jarg2) {
6236   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6237   float arg2 ;
6238
6239   arg1 = (Dali::Vector4 *)jarg1;
6240   arg2 = (float)jarg2;
6241   if (arg1) (arg1)->p = arg2;
6242 }
6243
6244
6245 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_p_get(void * jarg1) {
6246   float jresult ;
6247   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6248   float result;
6249
6250   arg1 = (Dali::Vector4 *)jarg1;
6251   result = (float) ((arg1)->p);
6252   jresult = result;
6253   return jresult;
6254 }
6255
6256
6257 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_W_set(void * jarg1, float jarg2) {
6258   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6259   float arg2 ;
6260
6261   arg1 = (Dali::Vector4 *)jarg1;
6262   arg2 = (float)jarg2;
6263   if (arg1) (arg1)->w = arg2;
6264 }
6265
6266
6267 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_W_get(void * jarg1) {
6268   float jresult ;
6269   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6270   float result;
6271
6272   arg1 = (Dali::Vector4 *)jarg1;
6273   result = (float) ((arg1)->w);
6274   jresult = result;
6275   return jresult;
6276 }
6277
6278
6279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_a_set(void * jarg1, float jarg2) {
6280   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6281   float arg2 ;
6282
6283   arg1 = (Dali::Vector4 *)jarg1;
6284   arg2 = (float)jarg2;
6285   if (arg1) (arg1)->a = arg2;
6286 }
6287
6288
6289 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_a_get(void * jarg1) {
6290   float jresult ;
6291   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6292   float result;
6293
6294   arg1 = (Dali::Vector4 *)jarg1;
6295   result = (float) ((arg1)->a);
6296   jresult = result;
6297   return jresult;
6298 }
6299
6300
6301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_q_set(void * jarg1, float jarg2) {
6302   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6303   float arg2 ;
6304
6305   arg1 = (Dali::Vector4 *)jarg1;
6306   arg2 = (float)jarg2;
6307   if (arg1) (arg1)->q = arg2;
6308 }
6309
6310
6311 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_q_get(void * jarg1) {
6312   float jresult ;
6313   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6314   float result;
6315
6316   arg1 = (Dali::Vector4 *)jarg1;
6317   result = (float) ((arg1)->q);
6318   jresult = result;
6319   return jresult;
6320 }
6321
6322
6323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector4(void * jarg1) {
6324   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6325
6326   arg1 = (Dali::Vector4 *)jarg1;
6327   {
6328     try {
6329       delete arg1;
6330     } CALL_CATCH_EXCEPTION();
6331   }
6332
6333 }
6334
6335
6336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_2(void * jarg1, void * jarg2) {
6337   void * jresult ;
6338   Dali::Vector4 *arg1 = 0 ;
6339   Dali::Vector4 *arg2 = 0 ;
6340   Dali::Vector4 result;
6341
6342   arg1 = (Dali::Vector4 *)jarg1;
6343   if (!arg1) {
6344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6345     return 0;
6346   }
6347   arg2 = (Dali::Vector4 *)jarg2;
6348   if (!arg2) {
6349     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6350     return 0;
6351   }
6352   {
6353     try {
6354       result = Dali::Min((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
6355     } CALL_CATCH_EXCEPTION(0);
6356   }
6357
6358   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6359   return jresult;
6360 }
6361
6362
6363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_2(void * jarg1, void * jarg2) {
6364   void * jresult ;
6365   Dali::Vector4 *arg1 = 0 ;
6366   Dali::Vector4 *arg2 = 0 ;
6367   Dali::Vector4 result;
6368
6369   arg1 = (Dali::Vector4 *)jarg1;
6370   if (!arg1) {
6371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6372     return 0;
6373   }
6374   arg2 = (Dali::Vector4 *)jarg2;
6375   if (!arg2) {
6376     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6377     return 0;
6378   }
6379   {
6380     try {
6381       result = Dali::Max((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
6382     } CALL_CATCH_EXCEPTION(0);
6383   }
6384
6385   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6386   return jresult;
6387 }
6388
6389
6390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
6391   void * jresult ;
6392   Dali::Vector4 *arg1 = 0 ;
6393   float *arg2 = 0 ;
6394   float *arg3 = 0 ;
6395   float temp2 ;
6396   float temp3 ;
6397   Dali::Vector4 result;
6398
6399   arg1 = (Dali::Vector4 *)jarg1;
6400   if (!arg1) {
6401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6402     return 0;
6403   }
6404   temp2 = (float)jarg2;
6405   arg2 = &temp2;
6406   temp3 = (float)jarg3;
6407   arg3 = &temp3;
6408   {
6409     try {
6410       result = Dali::Clamp((Dali::Vector4 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
6411     } CALL_CATCH_EXCEPTION(0);
6412   }
6413
6414   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6415   return jresult;
6416 }
6417
6418
6419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_0() {
6420   void * jresult ;
6421   Dali::Uint16Pair *result = 0 ;
6422
6423   {
6424     try {
6425       result = (Dali::Uint16Pair *)new Dali::Uint16Pair();
6426     } CALL_CATCH_EXCEPTION(0);
6427   }
6428
6429   jresult = (void *)result;
6430   return jresult;
6431 }
6432
6433
6434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
6435   void * jresult ;
6436   uint32_t arg1 ;
6437   uint32_t arg2 ;
6438   Dali::Uint16Pair *result = 0 ;
6439
6440   arg1 = (uint32_t)jarg1;
6441   arg2 = (uint32_t)jarg2;
6442   {
6443     try {
6444       result = (Dali::Uint16Pair *)new Dali::Uint16Pair(arg1,arg2);
6445     } CALL_CATCH_EXCEPTION(0);
6446   }
6447
6448   jresult = (void *)result;
6449   return jresult;
6450 }
6451
6452
6453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_2(void * jarg1) {
6454   void * jresult ;
6455   Dali::Uint16Pair *arg1 = 0 ;
6456   Dali::Uint16Pair *result = 0 ;
6457
6458   arg1 = (Dali::Uint16Pair *)jarg1;
6459   if (!arg1) {
6460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
6461     return 0;
6462   }
6463   {
6464     try {
6465       result = (Dali::Uint16Pair *)new Dali::Uint16Pair((Dali::Uint16Pair const &)*arg1);
6466     } CALL_CATCH_EXCEPTION(0);
6467   }
6468
6469   jresult = (void *)result;
6470   return jresult;
6471 }
6472
6473
6474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetWidth(void * jarg1, unsigned short jarg2) {
6475   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6476   uint16_t arg2 ;
6477
6478   arg1 = (Dali::Uint16Pair *)jarg1;
6479   arg2 = (uint16_t)jarg2;
6480   {
6481     try {
6482       (arg1)->SetWidth(arg2);
6483     } CALL_CATCH_EXCEPTION();
6484   }
6485
6486 }
6487
6488
6489 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetWidth(void * jarg1) {
6490   unsigned short jresult ;
6491   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6492   uint16_t result;
6493
6494   arg1 = (Dali::Uint16Pair *)jarg1;
6495   {
6496     try {
6497       result = ((Dali::Uint16Pair const *)arg1)->GetWidth();
6498     } CALL_CATCH_EXCEPTION(0);
6499   }
6500
6501   jresult = result;
6502   return jresult;
6503 }
6504
6505
6506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetHeight(void * jarg1, unsigned short jarg2) {
6507   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6508   uint16_t arg2 ;
6509
6510   arg1 = (Dali::Uint16Pair *)jarg1;
6511   arg2 = (uint16_t)jarg2;
6512   {
6513     try {
6514       (arg1)->SetHeight(arg2);
6515     } CALL_CATCH_EXCEPTION();
6516   }
6517
6518 }
6519
6520
6521 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetHeight(void * jarg1) {
6522   unsigned short jresult ;
6523   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6524   uint16_t result;
6525
6526   arg1 = (Dali::Uint16Pair *)jarg1;
6527   {
6528     try {
6529       result = ((Dali::Uint16Pair const *)arg1)->GetHeight();
6530     } CALL_CATCH_EXCEPTION(0);
6531   }
6532
6533   jresult = result;
6534   return jresult;
6535 }
6536
6537
6538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetX(void * jarg1, unsigned short jarg2) {
6539   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6540   uint16_t arg2 ;
6541
6542   arg1 = (Dali::Uint16Pair *)jarg1;
6543   arg2 = (uint16_t)jarg2;
6544   {
6545     try {
6546       (arg1)->SetX(arg2);
6547     } CALL_CATCH_EXCEPTION();
6548   }
6549
6550 }
6551
6552
6553 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetX(void * jarg1) {
6554   unsigned short jresult ;
6555   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6556   uint16_t result;
6557
6558   arg1 = (Dali::Uint16Pair *)jarg1;
6559   {
6560     try {
6561       result = ((Dali::Uint16Pair const *)arg1)->GetX();
6562     } CALL_CATCH_EXCEPTION(0);
6563   }
6564
6565   jresult = result;
6566   return jresult;
6567 }
6568
6569
6570 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetY(void * jarg1, unsigned short jarg2) {
6571   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6572   uint16_t arg2 ;
6573
6574   arg1 = (Dali::Uint16Pair *)jarg1;
6575   arg2 = (uint16_t)jarg2;
6576   {
6577     try {
6578       (arg1)->SetY(arg2);
6579     } CALL_CATCH_EXCEPTION();
6580   }
6581
6582 }
6583
6584
6585 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetY(void * jarg1) {
6586   unsigned short jresult ;
6587   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6588   uint16_t result;
6589
6590   arg1 = (Dali::Uint16Pair *)jarg1;
6591   {
6592     try {
6593       result = ((Dali::Uint16Pair const *)arg1)->GetY();
6594     } CALL_CATCH_EXCEPTION(0);
6595   }
6596
6597   jresult = result;
6598   return jresult;
6599 }
6600
6601
6602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Uint16Pair_Assign(void * jarg1, void * jarg2) {
6603   void * jresult ;
6604   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6605   Dali::Uint16Pair *arg2 = 0 ;
6606   Dali::Uint16Pair *result = 0 ;
6607
6608   arg1 = (Dali::Uint16Pair *)jarg1;
6609   arg2 = (Dali::Uint16Pair *)jarg2;
6610   if (!arg2) {
6611     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
6612     return 0;
6613   }
6614   {
6615     try {
6616       result = (Dali::Uint16Pair *) &(arg1)->operator =((Dali::Uint16Pair const &)*arg2);
6617     } CALL_CATCH_EXCEPTION(0);
6618   }
6619
6620   jresult = (void *)result;
6621   return jresult;
6622 }
6623
6624
6625 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_EqualTo(void * jarg1, void * jarg2) {
6626   unsigned int jresult ;
6627   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6628   Dali::Uint16Pair *arg2 = 0 ;
6629   bool result;
6630
6631   arg1 = (Dali::Uint16Pair *)jarg1;
6632   arg2 = (Dali::Uint16Pair *)jarg2;
6633   if (!arg2) {
6634     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
6635     return 0;
6636   }
6637   {
6638     try {
6639       result = (bool)((Dali::Uint16Pair const *)arg1)->operator ==((Dali::Uint16Pair const &)*arg2);
6640     } CALL_CATCH_EXCEPTION(0);
6641   }
6642
6643   jresult = result;
6644   return jresult;
6645 }
6646
6647
6648 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_NotEqualTo(void * jarg1, void * jarg2) {
6649   unsigned int jresult ;
6650   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6651   Dali::Uint16Pair *arg2 = 0 ;
6652   bool result;
6653
6654   arg1 = (Dali::Uint16Pair *)jarg1;
6655   arg2 = (Dali::Uint16Pair *)jarg2;
6656   if (!arg2) {
6657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
6658     return 0;
6659   }
6660   {
6661     try {
6662       result = (bool)((Dali::Uint16Pair const *)arg1)->operator !=((Dali::Uint16Pair const &)*arg2);
6663     } CALL_CATCH_EXCEPTION(0);
6664   }
6665
6666   jresult = result;
6667   return jresult;
6668 }
6669
6670
6671 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_LessThan(void * jarg1, void * jarg2) {
6672   unsigned int jresult ;
6673   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6674   Dali::Uint16Pair *arg2 = 0 ;
6675   bool result;
6676
6677   arg1 = (Dali::Uint16Pair *)jarg1;
6678   arg2 = (Dali::Uint16Pair *)jarg2;
6679   if (!arg2) {
6680     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
6681     return 0;
6682   }
6683   {
6684     try {
6685       result = (bool)((Dali::Uint16Pair const *)arg1)->operator <((Dali::Uint16Pair const &)*arg2);
6686     } CALL_CATCH_EXCEPTION(0);
6687   }
6688
6689   jresult = result;
6690   return jresult;
6691 }
6692
6693
6694 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_GreaterThan(void * jarg1, void * jarg2) {
6695   unsigned int jresult ;
6696   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6697   Dali::Uint16Pair *arg2 = 0 ;
6698   bool result;
6699
6700   arg1 = (Dali::Uint16Pair *)jarg1;
6701   arg2 = (Dali::Uint16Pair *)jarg2;
6702   if (!arg2) {
6703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
6704     return 0;
6705   }
6706   {
6707     try {
6708       result = (bool)((Dali::Uint16Pair const *)arg1)->operator >((Dali::Uint16Pair const &)*arg2);
6709     } CALL_CATCH_EXCEPTION(0);
6710   }
6711
6712   jresult = result;
6713   return jresult;
6714 }
6715
6716
6717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Uint16Pair(void * jarg1) {
6718   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
6719
6720   arg1 = (Dali::Uint16Pair *)jarg1;
6721   {
6722     try {
6723       delete arg1;
6724     } CALL_CATCH_EXCEPTION();
6725   }
6726
6727 }
6728
6729
6730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_0() {
6731   void * jresult ;
6732   Dali::Degree *result = 0 ;
6733
6734   {
6735     try {
6736       result = (Dali::Degree *)new Dali::Degree();
6737     } CALL_CATCH_EXCEPTION(0);
6738   }
6739
6740   jresult = (void *)result;
6741   return jresult;
6742 }
6743
6744
6745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_1(float jarg1) {
6746   void * jresult ;
6747   float arg1 ;
6748   Dali::Degree *result = 0 ;
6749
6750   arg1 = (float)jarg1;
6751   {
6752     try {
6753       result = (Dali::Degree *)new Dali::Degree(arg1);
6754     } CALL_CATCH_EXCEPTION(0);
6755   }
6756
6757   jresult = (void *)result;
6758   return jresult;
6759 }
6760
6761
6762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_2(void * jarg1) {
6763   void * jresult ;
6764   Dali::Radian arg1 ;
6765   Dali::Radian *argp1 ;
6766   Dali::Degree *result = 0 ;
6767
6768   argp1 = (Dali::Radian *)jarg1;
6769   if (!argp1) {
6770     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
6771     return 0;
6772   }
6773   arg1 = *argp1;
6774   {
6775     try {
6776       result = (Dali::Degree *)new Dali::Degree(arg1);
6777     } CALL_CATCH_EXCEPTION(0);
6778   }
6779
6780   jresult = (void *)result;
6781   return jresult;
6782 }
6783
6784
6785 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Degree_degree_set(void * jarg1, float jarg2) {
6786   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
6787   float arg2 ;
6788
6789   arg1 = (Dali::Degree *)jarg1;
6790   arg2 = (float)jarg2;
6791   if (arg1) (arg1)->degree = arg2;
6792 }
6793
6794
6795 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Degree_degree_get(void * jarg1) {
6796   float jresult ;
6797   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
6798   float result;
6799
6800   arg1 = (Dali::Degree *)jarg1;
6801   result = (float) ((arg1)->degree);
6802   jresult = result;
6803   return jresult;
6804 }
6805
6806
6807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Degree(void * jarg1) {
6808   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
6809
6810   arg1 = (Dali::Degree *)jarg1;
6811   {
6812     try {
6813       delete arg1;
6814     } CALL_CATCH_EXCEPTION();
6815   }
6816
6817 }
6818
6819
6820 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_360_get() {
6821   void * jresult ;
6822   Dali::Radian *result = 0 ;
6823
6824   result = (Dali::Radian *)&Dali::ANGLE_360;
6825   jresult = (void *)result;
6826   return jresult;
6827 }
6828
6829
6830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_315_get() {
6831   void * jresult ;
6832   Dali::Radian *result = 0 ;
6833
6834   result = (Dali::Radian *)&Dali::ANGLE_315;
6835   jresult = (void *)result;
6836   return jresult;
6837 }
6838
6839
6840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_270_get() {
6841   void * jresult ;
6842   Dali::Radian *result = 0 ;
6843
6844   result = (Dali::Radian *)&Dali::ANGLE_270;
6845   jresult = (void *)result;
6846   return jresult;
6847 }
6848
6849
6850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_225_get() {
6851   void * jresult ;
6852   Dali::Radian *result = 0 ;
6853
6854   result = (Dali::Radian *)&Dali::ANGLE_225;
6855   jresult = (void *)result;
6856   return jresult;
6857 }
6858
6859
6860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_180_get() {
6861   void * jresult ;
6862   Dali::Radian *result = 0 ;
6863
6864   result = (Dali::Radian *)&Dali::ANGLE_180;
6865   jresult = (void *)result;
6866   return jresult;
6867 }
6868
6869
6870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_135_get() {
6871   void * jresult ;
6872   Dali::Radian *result = 0 ;
6873
6874   result = (Dali::Radian *)&Dali::ANGLE_135;
6875   jresult = (void *)result;
6876   return jresult;
6877 }
6878
6879
6880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_120_get() {
6881   void * jresult ;
6882   Dali::Radian *result = 0 ;
6883
6884   result = (Dali::Radian *)&Dali::ANGLE_120;
6885   jresult = (void *)result;
6886   return jresult;
6887 }
6888
6889
6890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_90_get() {
6891   void * jresult ;
6892   Dali::Radian *result = 0 ;
6893
6894   result = (Dali::Radian *)&Dali::ANGLE_90;
6895   jresult = (void *)result;
6896   return jresult;
6897 }
6898
6899
6900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_60_get() {
6901   void * jresult ;
6902   Dali::Radian *result = 0 ;
6903
6904   result = (Dali::Radian *)&Dali::ANGLE_60;
6905   jresult = (void *)result;
6906   return jresult;
6907 }
6908
6909
6910 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_45_get() {
6911   void * jresult ;
6912   Dali::Radian *result = 0 ;
6913
6914   result = (Dali::Radian *)&Dali::ANGLE_45;
6915   jresult = (void *)result;
6916   return jresult;
6917 }
6918
6919
6920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_30_get() {
6921   void * jresult ;
6922   Dali::Radian *result = 0 ;
6923
6924   result = (Dali::Radian *)&Dali::ANGLE_30;
6925   jresult = (void *)result;
6926   return jresult;
6927 }
6928
6929
6930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_0_get() {
6931   void * jresult ;
6932   Dali::Radian *result = 0 ;
6933
6934   result = (Dali::Radian *)&Dali::ANGLE_0;
6935   jresult = (void *)result;
6936   return jresult;
6937 }
6938
6939
6940 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_5(void * jarg1, void * jarg2) {
6941   unsigned int jresult ;
6942   Dali::Degree *arg1 = 0 ;
6943   Dali::Degree *arg2 = 0 ;
6944   bool result;
6945
6946   arg1 = (Dali::Degree *)jarg1;
6947   if (!arg1) {
6948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
6949     return 0;
6950   }
6951   arg2 = (Dali::Degree *)jarg2;
6952   if (!arg2) {
6953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
6954     return 0;
6955   }
6956   {
6957     try {
6958       result = (bool)Dali::operator ==((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
6959     } CALL_CATCH_EXCEPTION(0);
6960   }
6961
6962   jresult = result;
6963   return jresult;
6964 }
6965
6966
6967 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_4(void * jarg1, void * jarg2) {
6968   unsigned int jresult ;
6969   Dali::Degree *arg1 = 0 ;
6970   Dali::Degree *arg2 = 0 ;
6971   bool result;
6972
6973   arg1 = (Dali::Degree *)jarg1;
6974   if (!arg1) {
6975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
6976     return 0;
6977   }
6978   arg2 = (Dali::Degree *)jarg2;
6979   if (!arg2) {
6980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
6981     return 0;
6982   }
6983   {
6984     try {
6985       result = (bool)Dali::operator !=((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
6986     } CALL_CATCH_EXCEPTION(0);
6987   }
6988
6989   jresult = result;
6990   return jresult;
6991 }
6992
6993
6994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3) {
6995   void * jresult ;
6996   Dali::Degree arg1 ;
6997   float arg2 ;
6998   float arg3 ;
6999   Dali::Degree *argp1 ;
7000   Dali::Degree result;
7001
7002   argp1 = (Dali::Degree *)jarg1;
7003   if (!argp1) {
7004     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
7005     return 0;
7006   }
7007   arg1 = *argp1;
7008   arg2 = (float)jarg2;
7009   arg3 = (float)jarg3;
7010   {
7011     try {
7012       result = Dali::Clamp(arg1,arg2,arg3);
7013     } CALL_CATCH_EXCEPTION(0);
7014   }
7015
7016   jresult = new Dali::Degree((const Dali::Degree &)result);
7017   return jresult;
7018 }
7019
7020
7021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_0() {
7022   void * jresult ;
7023   Dali::Radian *result = 0 ;
7024
7025   {
7026     try {
7027       result = (Dali::Radian *)new Dali::Radian();
7028     } CALL_CATCH_EXCEPTION(0);
7029   }
7030
7031   jresult = (void *)result;
7032   return jresult;
7033 }
7034
7035
7036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_1(float jarg1) {
7037   void * jresult ;
7038   float arg1 ;
7039   Dali::Radian *result = 0 ;
7040
7041   arg1 = (float)jarg1;
7042   {
7043     try {
7044       result = (Dali::Radian *)new Dali::Radian(arg1);
7045     } CALL_CATCH_EXCEPTION(0);
7046   }
7047
7048   jresult = (void *)result;
7049   return jresult;
7050 }
7051
7052
7053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_2(void * jarg1) {
7054   void * jresult ;
7055   Dali::Degree arg1 ;
7056   Dali::Degree *argp1 ;
7057   Dali::Radian *result = 0 ;
7058
7059   argp1 = (Dali::Degree *)jarg1;
7060   if (!argp1) {
7061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
7062     return 0;
7063   }
7064   arg1 = *argp1;
7065   {
7066     try {
7067       result = (Dali::Radian *)new Dali::Radian(arg1);
7068     } CALL_CATCH_EXCEPTION(0);
7069   }
7070
7071   jresult = (void *)result;
7072   return jresult;
7073 }
7074
7075
7076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_0(void * jarg1, float jarg2) {
7077   void * jresult ;
7078   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
7079   float arg2 ;
7080   Dali::Radian *result = 0 ;
7081
7082   arg1 = (Dali::Radian *)jarg1;
7083   arg2 = (float)jarg2;
7084   {
7085     try {
7086       result = (Dali::Radian *) &(arg1)->operator =(arg2);
7087     } CALL_CATCH_EXCEPTION(0);
7088   }
7089
7090   jresult = (void *)result;
7091   return jresult;
7092 }
7093
7094
7095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_1(void * jarg1, void * jarg2) {
7096   void * jresult ;
7097   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
7098   Dali::Degree arg2 ;
7099   Dali::Degree *argp2 ;
7100   Dali::Radian *result = 0 ;
7101
7102   arg1 = (Dali::Radian *)jarg1;
7103   argp2 = (Dali::Degree *)jarg2;
7104   if (!argp2) {
7105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
7106     return 0;
7107   }
7108   arg2 = *argp2;
7109   {
7110     try {
7111       result = (Dali::Radian *) &(arg1)->operator =(arg2);
7112     } CALL_CATCH_EXCEPTION(0);
7113   }
7114
7115   jresult = (void *)result;
7116   return jresult;
7117 }
7118
7119
7120 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_ConvertToFloat(void * jarg1) {
7121   float jresult ;
7122   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
7123   float result;
7124
7125   arg1 = (Dali::Radian *)jarg1;
7126   {
7127     try {
7128       result = (float)((Dali::Radian const *)arg1)->operator float();
7129     } CALL_CATCH_EXCEPTION(0);
7130   }
7131
7132   jresult = result;
7133   return jresult;
7134 }
7135
7136
7137 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Radian_radian_set(void * jarg1, float jarg2) {
7138   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
7139   float arg2 ;
7140
7141   arg1 = (Dali::Radian *)jarg1;
7142   arg2 = (float)jarg2;
7143   if (arg1) (arg1)->radian = arg2;
7144 }
7145
7146
7147 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_radian_get(void * jarg1) {
7148   float jresult ;
7149   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
7150   float result;
7151
7152   arg1 = (Dali::Radian *)jarg1;
7153   result = (float) ((arg1)->radian);
7154   jresult = result;
7155   return jresult;
7156 }
7157
7158
7159 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Radian(void * jarg1) {
7160   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
7161
7162   arg1 = (Dali::Radian *)jarg1;
7163   {
7164     try {
7165       delete arg1;
7166     } CALL_CATCH_EXCEPTION();
7167   }
7168
7169 }
7170
7171
7172 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_6(void * jarg1, void * jarg2) {
7173   unsigned int jresult ;
7174   Dali::Radian arg1 ;
7175   Dali::Radian arg2 ;
7176   Dali::Radian *argp1 ;
7177   Dali::Radian *argp2 ;
7178   bool result;
7179
7180   argp1 = (Dali::Radian *)jarg1;
7181   if (!argp1) {
7182     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7183     return 0;
7184   }
7185   arg1 = *argp1;
7186   argp2 = (Dali::Radian *)jarg2;
7187   if (!argp2) {
7188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7189     return 0;
7190   }
7191   arg2 = *argp2;
7192   {
7193     try {
7194       result = (bool)Dali::operator ==(arg1,arg2);
7195     } CALL_CATCH_EXCEPTION(0);
7196   }
7197
7198   jresult = result;
7199   return jresult;
7200 }
7201
7202
7203 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_5(void * jarg1, void * jarg2) {
7204   unsigned int jresult ;
7205   Dali::Radian arg1 ;
7206   Dali::Radian arg2 ;
7207   Dali::Radian *argp1 ;
7208   Dali::Radian *argp2 ;
7209   bool result;
7210
7211   argp1 = (Dali::Radian *)jarg1;
7212   if (!argp1) {
7213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7214     return 0;
7215   }
7216   arg1 = *argp1;
7217   argp2 = (Dali::Radian *)jarg2;
7218   if (!argp2) {
7219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7220     return 0;
7221   }
7222   arg2 = *argp2;
7223   {
7224     try {
7225       result = (bool)Dali::operator !=(arg1,arg2);
7226     } CALL_CATCH_EXCEPTION(0);
7227   }
7228
7229   jresult = result;
7230   return jresult;
7231 }
7232
7233
7234 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_7(void * jarg1, void * jarg2) {
7235   unsigned int jresult ;
7236   Dali::Radian arg1 ;
7237   Dali::Degree arg2 ;
7238   Dali::Radian *argp1 ;
7239   Dali::Degree *argp2 ;
7240   bool result;
7241
7242   argp1 = (Dali::Radian *)jarg1;
7243   if (!argp1) {
7244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7245     return 0;
7246   }
7247   arg1 = *argp1;
7248   argp2 = (Dali::Degree *)jarg2;
7249   if (!argp2) {
7250     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
7251     return 0;
7252   }
7253   arg2 = *argp2;
7254   {
7255     try {
7256       result = (bool)Dali::operator ==(arg1,arg2);
7257     } CALL_CATCH_EXCEPTION(0);
7258   }
7259
7260   jresult = result;
7261   return jresult;
7262 }
7263
7264
7265 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_6(void * jarg1, void * jarg2) {
7266   unsigned int jresult ;
7267   Dali::Radian arg1 ;
7268   Dali::Degree arg2 ;
7269   Dali::Radian *argp1 ;
7270   Dali::Degree *argp2 ;
7271   bool result;
7272
7273   argp1 = (Dali::Radian *)jarg1;
7274   if (!argp1) {
7275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7276     return 0;
7277   }
7278   arg1 = *argp1;
7279   argp2 = (Dali::Degree *)jarg2;
7280   if (!argp2) {
7281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
7282     return 0;
7283   }
7284   arg2 = *argp2;
7285   {
7286     try {
7287       result = (bool)Dali::operator !=(arg1,arg2);
7288     } CALL_CATCH_EXCEPTION(0);
7289   }
7290
7291   jresult = result;
7292   return jresult;
7293 }
7294
7295
7296 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_8(void * jarg1, void * jarg2) {
7297   unsigned int jresult ;
7298   Dali::Degree arg1 ;
7299   Dali::Radian arg2 ;
7300   Dali::Degree *argp1 ;
7301   Dali::Radian *argp2 ;
7302   bool result;
7303
7304   argp1 = (Dali::Degree *)jarg1;
7305   if (!argp1) {
7306     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
7307     return 0;
7308   }
7309   arg1 = *argp1;
7310   argp2 = (Dali::Radian *)jarg2;
7311   if (!argp2) {
7312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7313     return 0;
7314   }
7315   arg2 = *argp2;
7316   {
7317     try {
7318       result = (bool)Dali::operator ==(arg1,arg2);
7319     } CALL_CATCH_EXCEPTION(0);
7320   }
7321
7322   jresult = result;
7323   return jresult;
7324 }
7325
7326
7327 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_7(void * jarg1, void * jarg2) {
7328   unsigned int jresult ;
7329   Dali::Degree arg1 ;
7330   Dali::Radian arg2 ;
7331   Dali::Degree *argp1 ;
7332   Dali::Radian *argp2 ;
7333   bool result;
7334
7335   argp1 = (Dali::Degree *)jarg1;
7336   if (!argp1) {
7337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
7338     return 0;
7339   }
7340   arg1 = *argp1;
7341   argp2 = (Dali::Radian *)jarg2;
7342   if (!argp2) {
7343     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7344     return 0;
7345   }
7346   arg2 = *argp2;
7347   {
7348     try {
7349       result = (bool)Dali::operator !=(arg1,arg2);
7350     } CALL_CATCH_EXCEPTION(0);
7351   }
7352
7353   jresult = result;
7354   return jresult;
7355 }
7356
7357
7358 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_0(void * jarg1, void * jarg2) {
7359   unsigned int jresult ;
7360   Dali::Radian arg1 ;
7361   Dali::Radian arg2 ;
7362   Dali::Radian *argp1 ;
7363   Dali::Radian *argp2 ;
7364   bool result;
7365
7366   argp1 = (Dali::Radian *)jarg1;
7367   if (!argp1) {
7368     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7369     return 0;
7370   }
7371   arg1 = *argp1;
7372   argp2 = (Dali::Radian *)jarg2;
7373   if (!argp2) {
7374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7375     return 0;
7376   }
7377   arg2 = *argp2;
7378   {
7379     try {
7380       result = (bool)Dali::operator >(arg1,arg2);
7381     } CALL_CATCH_EXCEPTION(0);
7382   }
7383
7384   jresult = result;
7385   return jresult;
7386 }
7387
7388
7389 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_1(void * jarg1, void * jarg2) {
7390   unsigned int jresult ;
7391   Dali::Radian arg1 ;
7392   Dali::Degree arg2 ;
7393   Dali::Radian *argp1 ;
7394   Dali::Degree *argp2 ;
7395   bool result;
7396
7397   argp1 = (Dali::Radian *)jarg1;
7398   if (!argp1) {
7399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7400     return 0;
7401   }
7402   arg1 = *argp1;
7403   argp2 = (Dali::Degree *)jarg2;
7404   if (!argp2) {
7405     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
7406     return 0;
7407   }
7408   arg2 = *argp2;
7409   {
7410     try {
7411       result = (bool)Dali::operator >(arg1,arg2);
7412     } CALL_CATCH_EXCEPTION(0);
7413   }
7414
7415   jresult = result;
7416   return jresult;
7417 }
7418
7419
7420 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_2(void * jarg1, void * jarg2) {
7421   unsigned int jresult ;
7422   Dali::Degree arg1 ;
7423   Dali::Radian arg2 ;
7424   Dali::Degree *argp1 ;
7425   Dali::Radian *argp2 ;
7426   bool result;
7427
7428   argp1 = (Dali::Degree *)jarg1;
7429   if (!argp1) {
7430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
7431     return 0;
7432   }
7433   arg1 = *argp1;
7434   argp2 = (Dali::Radian *)jarg2;
7435   if (!argp2) {
7436     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7437     return 0;
7438   }
7439   arg2 = *argp2;
7440   {
7441     try {
7442       result = (bool)Dali::operator >(arg1,arg2);
7443     } CALL_CATCH_EXCEPTION(0);
7444   }
7445
7446   jresult = result;
7447   return jresult;
7448 }
7449
7450
7451 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_0(void * jarg1, void * jarg2) {
7452   unsigned int jresult ;
7453   Dali::Radian arg1 ;
7454   Dali::Radian arg2 ;
7455   Dali::Radian *argp1 ;
7456   Dali::Radian *argp2 ;
7457   bool result;
7458
7459   argp1 = (Dali::Radian *)jarg1;
7460   if (!argp1) {
7461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7462     return 0;
7463   }
7464   arg1 = *argp1;
7465   argp2 = (Dali::Radian *)jarg2;
7466   if (!argp2) {
7467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7468     return 0;
7469   }
7470   arg2 = *argp2;
7471   {
7472     try {
7473       result = (bool)Dali::operator <(arg1,arg2);
7474     } CALL_CATCH_EXCEPTION(0);
7475   }
7476
7477   jresult = result;
7478   return jresult;
7479 }
7480
7481
7482 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_1(void * jarg1, void * jarg2) {
7483   unsigned int jresult ;
7484   Dali::Radian arg1 ;
7485   Dali::Degree arg2 ;
7486   Dali::Radian *argp1 ;
7487   Dali::Degree *argp2 ;
7488   bool result;
7489
7490   argp1 = (Dali::Radian *)jarg1;
7491   if (!argp1) {
7492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7493     return 0;
7494   }
7495   arg1 = *argp1;
7496   argp2 = (Dali::Degree *)jarg2;
7497   if (!argp2) {
7498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
7499     return 0;
7500   }
7501   arg2 = *argp2;
7502   {
7503     try {
7504       result = (bool)Dali::operator <(arg1,arg2);
7505     } CALL_CATCH_EXCEPTION(0);
7506   }
7507
7508   jresult = result;
7509   return jresult;
7510 }
7511
7512
7513 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_2(void * jarg1, void * jarg2) {
7514   unsigned int jresult ;
7515   Dali::Degree arg1 ;
7516   Dali::Radian arg2 ;
7517   Dali::Degree *argp1 ;
7518   Dali::Radian *argp2 ;
7519   bool result;
7520
7521   argp1 = (Dali::Degree *)jarg1;
7522   if (!argp1) {
7523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
7524     return 0;
7525   }
7526   arg1 = *argp1;
7527   argp2 = (Dali::Radian *)jarg2;
7528   if (!argp2) {
7529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7530     return 0;
7531   }
7532   arg2 = *argp2;
7533   {
7534     try {
7535       result = (bool)Dali::operator <(arg1,arg2);
7536     } CALL_CATCH_EXCEPTION(0);
7537   }
7538
7539   jresult = result;
7540   return jresult;
7541 }
7542
7543
7544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Multiply(void * jarg1, float jarg2) {
7545   void * jresult ;
7546   Dali::Radian arg1 ;
7547   float arg2 ;
7548   Dali::Radian *argp1 ;
7549   Dali::Radian result;
7550
7551   argp1 = (Dali::Radian *)jarg1;
7552   if (!argp1) {
7553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7554     return 0;
7555   }
7556   arg1 = *argp1;
7557   arg2 = (float)jarg2;
7558   {
7559     try {
7560       result = Dali::operator *(arg1,arg2);
7561     } CALL_CATCH_EXCEPTION(0);
7562   }
7563
7564   jresult = new Dali::Radian((const Dali::Radian &)result);
7565   return jresult;
7566 }
7567
7568
7569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Subtract(void * jarg1) {
7570   void * jresult ;
7571   Dali::Radian arg1 ;
7572   Dali::Radian *argp1 ;
7573   Dali::Radian result;
7574
7575   argp1 = (Dali::Radian *)jarg1;
7576   if (!argp1) {
7577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7578     return 0;
7579   }
7580   arg1 = *argp1;
7581   {
7582     try {
7583       result = Dali::operator -(arg1);
7584     } CALL_CATCH_EXCEPTION(0);
7585   }
7586
7587   jresult = new Dali::Radian((const Dali::Radian &)result);
7588   return jresult;
7589 }
7590
7591
7592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_4(void * jarg1, float jarg2, float jarg3) {
7593   void * jresult ;
7594   Dali::Radian arg1 ;
7595   float arg2 ;
7596   float arg3 ;
7597   Dali::Radian *argp1 ;
7598   Dali::Radian result;
7599
7600   argp1 = (Dali::Radian *)jarg1;
7601   if (!argp1) {
7602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7603     return 0;
7604   }
7605   arg1 = *argp1;
7606   arg2 = (float)jarg2;
7607   arg3 = (float)jarg3;
7608   {
7609     try {
7610       result = Dali::Clamp(arg1,arg2,arg3);
7611     } CALL_CATCH_EXCEPTION(0);
7612   }
7613
7614   jresult = new Dali::Radian((const Dali::Radian &)result);
7615   return jresult;
7616 }
7617
7618
7619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_0() {
7620   void * jresult ;
7621   Dali::Quaternion *result = 0 ;
7622
7623   {
7624     try {
7625       result = (Dali::Quaternion *)new Dali::Quaternion();
7626     } CALL_CATCH_EXCEPTION(0);
7627   }
7628
7629   jresult = (void *)result;
7630   return jresult;
7631 }
7632
7633
7634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_1(void * jarg1, void * jarg2) {
7635   void * jresult ;
7636   Dali::Radian arg1 ;
7637   Dali::Vector3 *arg2 = 0 ;
7638   Dali::Radian *argp1 ;
7639   Dali::Quaternion *result = 0 ;
7640
7641   argp1 = (Dali::Radian *)jarg1;
7642   if (!argp1) {
7643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
7644     return 0;
7645   }
7646   arg1 = *argp1;
7647   arg2 = (Dali::Vector3 *)jarg2;
7648   if (!arg2) {
7649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7650     return 0;
7651   }
7652   {
7653     try {
7654       result = (Dali::Quaternion *)new Dali::Quaternion(arg1,(Dali::Vector3 const &)*arg2);
7655     } CALL_CATCH_EXCEPTION(0);
7656   }
7657
7658   jresult = (void *)result;
7659   return jresult;
7660 }
7661
7662
7663 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rotation(void * jarg1) {
7664   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
7665
7666   arg1 = (Dali::Quaternion *)jarg1;
7667   {
7668     try {
7669       delete arg1;
7670     } CALL_CATCH_EXCEPTION();
7671   }
7672
7673 }
7674
7675
7676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_IDENTITY_get() {
7677   void * jresult ;
7678   Dali::Quaternion *result = 0 ;
7679
7680   result = (Dali::Quaternion *)&Dali::Quaternion::IDENTITY;
7681   jresult = (void *)result;
7682   return jresult;
7683 }
7684
7685
7686 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_IsIdentity(void * jarg1) {
7687   unsigned int jresult ;
7688   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
7689   bool result;
7690
7691   arg1 = (Dali::Quaternion *)jarg1;
7692   {
7693     try {
7694       result = (bool)((Dali::Quaternion const *)arg1)->IsIdentity();
7695     } CALL_CATCH_EXCEPTION(0);
7696   }
7697
7698   jresult = result;
7699   return jresult;
7700 }
7701
7702
7703 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_GetAxisAngle(void * jarg1, void * jarg2, void * jarg3) {
7704   unsigned int jresult ;
7705   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
7706   Dali::Vector3 *arg2 = 0 ;
7707   Dali::Radian *arg3 = 0 ;
7708   bool result;
7709
7710   arg1 = (Dali::Quaternion *)jarg1;
7711   arg2 = (Dali::Vector3 *)jarg2;
7712   if (!arg2) {
7713     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
7714     return 0;
7715   }
7716   arg3 = (Dali::Radian *)jarg3;
7717   if (!arg3) {
7718     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian & type is null", 0);
7719     return 0;
7720   }
7721   {
7722     try {
7723       result = (bool)((Dali::Quaternion const *)arg1)->ToAxisAngle(*arg2,*arg3);
7724     } CALL_CATCH_EXCEPTION(0);
7725   }
7726
7727   jresult = result;
7728   return jresult;
7729 }
7730
7731
7732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Add(void * jarg1, void * jarg2) {
7733   void * jresult ;
7734   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
7735   Dali::Quaternion *arg2 = 0 ;
7736   Dali::Quaternion result;
7737
7738   arg1 = (Dali::Quaternion *)jarg1;
7739   arg2 = (Dali::Quaternion *)jarg2;
7740   if (!arg2) {
7741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
7742     return 0;
7743   }
7744   {
7745     try {
7746       result = ((Dali::Quaternion const *)arg1)->operator +((Dali::Quaternion const &)*arg2);
7747     } CALL_CATCH_EXCEPTION(0);
7748   }
7749
7750   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
7751   return jresult;
7752 }
7753
7754
7755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_0(void * jarg1, void * jarg2) {
7756   void * jresult ;
7757   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
7758   Dali::Quaternion *arg2 = 0 ;
7759   Dali::Quaternion result;
7760
7761   arg1 = (Dali::Quaternion *)jarg1;
7762   arg2 = (Dali::Quaternion *)jarg2;
7763   if (!arg2) {
7764     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
7765     return 0;
7766   }
7767   {
7768     try {
7769       result = ((Dali::Quaternion const *)arg1)->operator -((Dali::Quaternion const &)*arg2);
7770     } CALL_CATCH_EXCEPTION(0);
7771   }
7772
7773   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
7774   return jresult;
7775 }
7776
7777
7778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_0(void * jarg1, void * jarg2) {
7779   void * jresult ;
7780   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
7781   Dali::Quaternion *arg2 = 0 ;
7782   Dali::Quaternion result;
7783
7784   arg1 = (Dali::Quaternion *)jarg1;
7785   arg2 = (Dali::Quaternion *)jarg2;
7786   if (!arg2) {
7787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
7788     return 0;
7789   }
7790   {
7791     try {
7792       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Quaternion const &)*arg2);
7793     } CALL_CATCH_EXCEPTION(0);
7794   }
7795
7796   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
7797   return jresult;
7798 }
7799
7800
7801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_1(void * jarg1, void * jarg2) {
7802   void * jresult ;
7803   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
7804   Dali::Vector3 *arg2 = 0 ;
7805   Dali::Vector3 result;
7806
7807   arg1 = (Dali::Quaternion *)jarg1;
7808   arg2 = (Dali::Vector3 *)jarg2;
7809   if (!arg2) {
7810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7811     return 0;
7812   }
7813   {
7814     try {
7815       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
7816     } CALL_CATCH_EXCEPTION(0);
7817   }
7818
7819   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7820   return jresult;
7821 }
7822
7823
7824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_0(void * jarg1, void * jarg2) {
7825   void * jresult ;
7826   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
7827   Dali::Quaternion *arg2 = 0 ;
7828   Dali::Quaternion result;
7829
7830   arg1 = (Dali::Quaternion *)jarg1;
7831   arg2 = (Dali::Quaternion *)jarg2;
7832   if (!arg2) {
7833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
7834     return 0;
7835   }
7836   {
7837     try {
7838       result = ((Dali::Quaternion const *)arg1)->operator /((Dali::Quaternion const &)*arg2);
7839     } CALL_CATCH_EXCEPTION(0);
7840   }
7841
7842   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
7843   return jresult;
7844 }
7845
7846
7847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_2(void * jarg1, float jarg2) {
7848   void * jresult ;
7849   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
7850   float arg2 ;
7851   Dali::Quaternion result;
7852
7853   arg1 = (Dali::Quaternion *)jarg1;
7854   arg2 = (float)jarg2;
7855   {
7856     try {
7857       result = ((Dali::Quaternion const *)arg1)->operator *(arg2);
7858     } CALL_CATCH_EXCEPTION(0);
7859   }
7860
7861   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
7862   return jresult;
7863 }
7864
7865
7866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_1(void * jarg1, float jarg2) {
7867   void * jresult ;
7868   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
7869   float arg2 ;
7870   Dali::Quaternion result;
7871
7872   arg1 = (Dali::Quaternion *)jarg1;
7873   arg2 = (float)jarg2;
7874   {
7875     try {
7876       result = ((Dali::Quaternion const *)arg1)->operator /(arg2);
7877     } CALL_CATCH_EXCEPTION(0);
7878   }
7879
7880   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
7881   return jresult;
7882 }
7883
7884
7885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_1(void * jarg1) {
7886   void * jresult ;
7887   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
7888   Dali::Quaternion result;
7889
7890   arg1 = (Dali::Quaternion *)jarg1;
7891   {
7892     try {
7893       result = ((Dali::Quaternion const *)arg1)->operator -();
7894     } CALL_CATCH_EXCEPTION(0);
7895   }
7896
7897   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
7898   return jresult;
7899 }
7900
7901
7902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_AddAssign(void * jarg1, void * jarg2) {
7903   void * jresult ;
7904   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
7905   Dali::Quaternion *arg2 = 0 ;
7906   Dali::Quaternion *result = 0 ;
7907
7908   arg1 = (Dali::Quaternion *)jarg1;
7909   arg2 = (Dali::Quaternion *)jarg2;
7910   if (!arg2) {
7911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
7912     return 0;
7913   }
7914   {
7915     try {
7916       result = (Dali::Quaternion *) &(arg1)->operator +=((Dali::Quaternion const &)*arg2);
7917     } CALL_CATCH_EXCEPTION(0);
7918   }
7919
7920   jresult = (void *)result;
7921   return jresult;
7922 }
7923
7924
7925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SubtractAssign(void * jarg1, void * jarg2) {
7926   void * jresult ;
7927   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
7928   Dali::Quaternion *arg2 = 0 ;
7929   Dali::Quaternion *result = 0 ;
7930
7931   arg1 = (Dali::Quaternion *)jarg1;
7932   arg2 = (Dali::Quaternion *)jarg2;
7933   if (!arg2) {
7934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
7935     return 0;
7936   }
7937   {
7938     try {
7939       result = (Dali::Quaternion *) &(arg1)->operator -=((Dali::Quaternion const &)*arg2);
7940     } CALL_CATCH_EXCEPTION(0);
7941   }
7942
7943   jresult = (void *)result;
7944   return jresult;
7945 }
7946
7947
7948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
7949   void * jresult ;
7950   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
7951   Dali::Quaternion *arg2 = 0 ;
7952   Dali::Quaternion *result = 0 ;
7953
7954   arg1 = (Dali::Quaternion *)jarg1;
7955   arg2 = (Dali::Quaternion *)jarg2;
7956   if (!arg2) {
7957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
7958     return 0;
7959   }
7960   {
7961     try {
7962       result = (Dali::Quaternion *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
7963     } CALL_CATCH_EXCEPTION(0);
7964   }
7965
7966   jresult = (void *)result;
7967   return jresult;
7968 }
7969
7970
7971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
7972   void * jresult ;
7973   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
7974   float arg2 ;
7975   Dali::Quaternion *result = 0 ;
7976
7977   arg1 = (Dali::Quaternion *)jarg1;
7978   arg2 = (float)jarg2;
7979   {
7980     try {
7981       result = (Dali::Quaternion *) &(arg1)->operator *=(arg2);
7982     } CALL_CATCH_EXCEPTION(0);
7983   }
7984
7985   jresult = (void *)result;
7986   return jresult;
7987 }
7988
7989
7990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_DivideAssign(void * jarg1, float jarg2) {
7991   void * jresult ;
7992   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
7993   float arg2 ;
7994   Dali::Quaternion *result = 0 ;
7995
7996   arg1 = (Dali::Quaternion *)jarg1;
7997   arg2 = (float)jarg2;
7998   {
7999     try {
8000       result = (Dali::Quaternion *) &(arg1)->operator /=(arg2);
8001     } CALL_CATCH_EXCEPTION(0);
8002   }
8003
8004   jresult = (void *)result;
8005   return jresult;
8006 }
8007
8008
8009 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_EqualTo(void * jarg1, void * jarg2) {
8010   unsigned int jresult ;
8011   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
8012   Dali::Quaternion *arg2 = 0 ;
8013   bool result;
8014
8015   arg1 = (Dali::Quaternion *)jarg1;
8016   arg2 = (Dali::Quaternion *)jarg2;
8017   if (!arg2) {
8018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
8019     return 0;
8020   }
8021   {
8022     try {
8023       result = (bool)((Dali::Quaternion const *)arg1)->operator ==((Dali::Quaternion const &)*arg2);
8024     } CALL_CATCH_EXCEPTION(0);
8025   }
8026
8027   jresult = result;
8028   return jresult;
8029 }
8030
8031
8032 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_NotEqualTo(void * jarg1, void * jarg2) {
8033   unsigned int jresult ;
8034   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
8035   Dali::Quaternion *arg2 = 0 ;
8036   bool result;
8037
8038   arg1 = (Dali::Quaternion *)jarg1;
8039   arg2 = (Dali::Quaternion *)jarg2;
8040   if (!arg2) {
8041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
8042     return 0;
8043   }
8044   {
8045     try {
8046       result = (bool)((Dali::Quaternion const *)arg1)->operator !=((Dali::Quaternion const &)*arg2);
8047     } CALL_CATCH_EXCEPTION(0);
8048   }
8049
8050   jresult = result;
8051   return jresult;
8052 }
8053
8054
8055 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Length(void * jarg1) {
8056   float jresult ;
8057   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
8058   float result;
8059
8060   arg1 = (Dali::Quaternion *)jarg1;
8061   {
8062     try {
8063       result = (float)((Dali::Quaternion const *)arg1)->Length();
8064     } CALL_CATCH_EXCEPTION(0);
8065   }
8066
8067   jresult = result;
8068   return jresult;
8069 }
8070
8071
8072 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_LengthSquared(void * jarg1) {
8073   float jresult ;
8074   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
8075   float result;
8076
8077   arg1 = (Dali::Quaternion *)jarg1;
8078   {
8079     try {
8080       result = (float)((Dali::Quaternion const *)arg1)->LengthSquared();
8081     } CALL_CATCH_EXCEPTION(0);
8082   }
8083
8084   jresult = result;
8085   return jresult;
8086 }
8087
8088
8089 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Normalize(void * jarg1) {
8090   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
8091
8092   arg1 = (Dali::Quaternion *)jarg1;
8093   {
8094     try {
8095       (arg1)->Normalize();
8096     } CALL_CATCH_EXCEPTION();
8097   }
8098
8099 }
8100
8101
8102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Normalized(void * jarg1) {
8103   void * jresult ;
8104   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
8105   Dali::Quaternion result;
8106
8107   arg1 = (Dali::Quaternion *)jarg1;
8108   {
8109     try {
8110       result = ((Dali::Quaternion const *)arg1)->Normalized();
8111     } CALL_CATCH_EXCEPTION(0);
8112   }
8113
8114   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
8115   return jresult;
8116 }
8117
8118
8119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Conjugate(void * jarg1) {
8120   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
8121
8122   arg1 = (Dali::Quaternion *)jarg1;
8123   {
8124     try {
8125       (arg1)->Conjugate();
8126     } CALL_CATCH_EXCEPTION();
8127   }
8128
8129 }
8130
8131
8132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Invert(void * jarg1) {
8133   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
8134
8135   arg1 = (Dali::Quaternion *)jarg1;
8136   {
8137     try {
8138       (arg1)->Invert();
8139     } CALL_CATCH_EXCEPTION();
8140   }
8141
8142 }
8143
8144
8145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Log(void * jarg1) {
8146   void * jresult ;
8147   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
8148   Dali::Quaternion result;
8149
8150   arg1 = (Dali::Quaternion *)jarg1;
8151   {
8152     try {
8153       result = ((Dali::Quaternion const *)arg1)->Log();
8154     } CALL_CATCH_EXCEPTION(0);
8155   }
8156
8157   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
8158   return jresult;
8159 }
8160
8161
8162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Exp(void * jarg1) {
8163   void * jresult ;
8164   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
8165   Dali::Quaternion result;
8166
8167   arg1 = (Dali::Quaternion *)jarg1;
8168   {
8169     try {
8170       result = ((Dali::Quaternion const *)arg1)->Exp();
8171     } CALL_CATCH_EXCEPTION(0);
8172   }
8173
8174   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
8175   return jresult;
8176 }
8177
8178
8179 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Dot(void * jarg1, void * jarg2) {
8180   float jresult ;
8181   Dali::Quaternion *arg1 = 0 ;
8182   Dali::Quaternion *arg2 = 0 ;
8183   float result;
8184
8185   arg1 = (Dali::Quaternion *)jarg1;
8186   if (!arg1) {
8187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
8188     return 0;
8189   }
8190   arg2 = (Dali::Quaternion *)jarg2;
8191   if (!arg2) {
8192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
8193     return 0;
8194   }
8195   {
8196     try {
8197       result = (float)Dali::Quaternion::Dot((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
8198     } CALL_CATCH_EXCEPTION(0);
8199   }
8200
8201   jresult = result;
8202   return jresult;
8203 }
8204
8205
8206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Lerp(void * jarg1, void * jarg2, float jarg3) {
8207   void * jresult ;
8208   Dali::Quaternion *arg1 = 0 ;
8209   Dali::Quaternion *arg2 = 0 ;
8210   float arg3 ;
8211   Dali::Quaternion result;
8212
8213   arg1 = (Dali::Quaternion *)jarg1;
8214   if (!arg1) {
8215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
8216     return 0;
8217   }
8218   arg2 = (Dali::Quaternion *)jarg2;
8219   if (!arg2) {
8220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
8221     return 0;
8222   }
8223   arg3 = (float)jarg3;
8224   {
8225     try {
8226       result = Dali::Quaternion::Lerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
8227     } CALL_CATCH_EXCEPTION(0);
8228   }
8229
8230   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
8231   return jresult;
8232 }
8233
8234
8235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Slerp(void * jarg1, void * jarg2, float jarg3) {
8236   void * jresult ;
8237   Dali::Quaternion *arg1 = 0 ;
8238   Dali::Quaternion *arg2 = 0 ;
8239   float arg3 ;
8240   Dali::Quaternion result;
8241
8242   arg1 = (Dali::Quaternion *)jarg1;
8243   if (!arg1) {
8244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
8245     return 0;
8246   }
8247   arg2 = (Dali::Quaternion *)jarg2;
8248   if (!arg2) {
8249     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
8250     return 0;
8251   }
8252   arg3 = (float)jarg3;
8253   {
8254     try {
8255       result = Dali::Quaternion::Slerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
8256     } CALL_CATCH_EXCEPTION(0);
8257   }
8258
8259   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
8260   return jresult;
8261 }
8262
8263
8264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SlerpNoInvert(void * jarg1, void * jarg2, float jarg3) {
8265   void * jresult ;
8266   Dali::Quaternion *arg1 = 0 ;
8267   Dali::Quaternion *arg2 = 0 ;
8268   float arg3 ;
8269   Dali::Quaternion result;
8270
8271   arg1 = (Dali::Quaternion *)jarg1;
8272   if (!arg1) {
8273     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
8274     return 0;
8275   }
8276   arg2 = (Dali::Quaternion *)jarg2;
8277   if (!arg2) {
8278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
8279     return 0;
8280   }
8281   arg3 = (float)jarg3;
8282   {
8283     try {
8284       result = Dali::Quaternion::SlerpNoInvert((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
8285     } CALL_CATCH_EXCEPTION(0);
8286   }
8287
8288   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
8289   return jresult;
8290 }
8291
8292
8293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Squad(void * jarg1, void * jarg2, void * jarg3, void * jarg4, float jarg5) {
8294   void * jresult ;
8295   Dali::Quaternion *arg1 = 0 ;
8296   Dali::Quaternion *arg2 = 0 ;
8297   Dali::Quaternion *arg3 = 0 ;
8298   Dali::Quaternion *arg4 = 0 ;
8299   float arg5 ;
8300   Dali::Quaternion result;
8301
8302   arg1 = (Dali::Quaternion *)jarg1;
8303   if (!arg1) {
8304     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
8305     return 0;
8306   }
8307   arg2 = (Dali::Quaternion *)jarg2;
8308   if (!arg2) {
8309     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
8310     return 0;
8311   }
8312   arg3 = (Dali::Quaternion *)jarg3;
8313   if (!arg3) {
8314     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
8315     return 0;
8316   }
8317   arg4 = (Dali::Quaternion *)jarg4;
8318   if (!arg4) {
8319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
8320     return 0;
8321   }
8322   arg5 = (float)jarg5;
8323   {
8324     try {
8325       result = Dali::Quaternion::Squad((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Quaternion const &)*arg4,arg5);
8326     } CALL_CATCH_EXCEPTION(0);
8327   }
8328
8329   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
8330   return jresult;
8331 }
8332
8333
8334 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_AngleBetween(void * jarg1, void * jarg2) {
8335   float jresult ;
8336   Dali::Quaternion *arg1 = 0 ;
8337   Dali::Quaternion *arg2 = 0 ;
8338   float result;
8339
8340   arg1 = (Dali::Quaternion *)jarg1;
8341   if (!arg1) {
8342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
8343     return 0;
8344   }
8345   arg2 = (Dali::Quaternion *)jarg2;
8346   if (!arg2) {
8347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
8348     return 0;
8349   }
8350   {
8351     try {
8352       result = (float)Dali::Quaternion::AngleBetween((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
8353     } CALL_CATCH_EXCEPTION(0);
8354   }
8355
8356   jresult = result;
8357   return jresult;
8358 }
8359
8360
8361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_0() {
8362   void * jresult ;
8363   Dali::Matrix *result = 0 ;
8364
8365   {
8366     try {
8367       result = (Dali::Matrix *)new Dali::Matrix();
8368     } CALL_CATCH_EXCEPTION(0);
8369   }
8370
8371   jresult = (void *)result;
8372   return jresult;
8373 }
8374
8375
8376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_1(unsigned int jarg1) {
8377   void * jresult ;
8378   bool arg1 ;
8379   Dali::Matrix *result = 0 ;
8380
8381   arg1 = jarg1 ? true : false;
8382   {
8383     try {
8384       result = (Dali::Matrix *)new Dali::Matrix(arg1);
8385     } CALL_CATCH_EXCEPTION(0);
8386   }
8387
8388   jresult = (void *)result;
8389   return jresult;
8390 }
8391
8392
8393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_2(float* jarg1) {
8394   void * jresult ;
8395   float *arg1 = (float *) 0 ;
8396   Dali::Matrix *result = 0 ;
8397
8398   arg1 = jarg1;
8399   {
8400     try {
8401       result = (Dali::Matrix *)new Dali::Matrix((float const *)arg1);
8402     } CALL_CATCH_EXCEPTION(0);
8403   }
8404
8405   jresult = (void *)result;
8406
8407
8408   return jresult;
8409 }
8410
8411
8412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_3(void * jarg1) {
8413   void * jresult ;
8414   Dali::Quaternion *arg1 = 0 ;
8415   Dali::Matrix *result = 0 ;
8416
8417   arg1 = (Dali::Quaternion *)jarg1;
8418   if (!arg1) {
8419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
8420     return 0;
8421   }
8422   {
8423     try {
8424       result = (Dali::Matrix *)new Dali::Matrix((Dali::Quaternion const &)*arg1);
8425     } CALL_CATCH_EXCEPTION(0);
8426   }
8427
8428   jresult = (void *)result;
8429   return jresult;
8430 }
8431
8432
8433 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_4(void * jarg1) {
8434   void * jresult ;
8435   Dali::Matrix *arg1 = 0 ;
8436   Dali::Matrix *result = 0 ;
8437
8438   arg1 = (Dali::Matrix *)jarg1;
8439   if (!arg1) {
8440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
8441     return 0;
8442   }
8443   {
8444     try {
8445       result = (Dali::Matrix *)new Dali::Matrix((Dali::Matrix const &)*arg1);
8446     } CALL_CATCH_EXCEPTION(0);
8447   }
8448
8449   jresult = (void *)result;
8450   return jresult;
8451 }
8452
8453
8454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Assign(void * jarg1, void * jarg2) {
8455   void * jresult ;
8456   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8457   Dali::Matrix *arg2 = 0 ;
8458   Dali::Matrix *result = 0 ;
8459
8460   arg1 = (Dali::Matrix *)jarg1;
8461   arg2 = (Dali::Matrix *)jarg2;
8462   if (!arg2) {
8463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
8464     return 0;
8465   }
8466   {
8467     try {
8468       result = (Dali::Matrix *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
8469     } CALL_CATCH_EXCEPTION(0);
8470   }
8471
8472   jresult = (void *)result;
8473   return jresult;
8474 }
8475
8476
8477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_IDENTITY_get() {
8478   void * jresult ;
8479   Dali::Matrix *result = 0 ;
8480
8481   result = (Dali::Matrix *)&Dali::Matrix::IDENTITY;
8482   jresult = (void *)result;
8483   return jresult;
8484 }
8485
8486
8487 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentity(void * jarg1) {
8488   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8489
8490   arg1 = (Dali::Matrix *)jarg1;
8491   {
8492     try {
8493       (arg1)->SetIdentity();
8494     } CALL_CATCH_EXCEPTION();
8495   }
8496
8497 }
8498
8499
8500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentityAndScale(void * jarg1, void * jarg2) {
8501   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8502   Dali::Vector3 *arg2 = 0 ;
8503
8504   arg1 = (Dali::Matrix *)jarg1;
8505   arg2 = (Dali::Vector3 *)jarg2;
8506   if (!arg2) {
8507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8508     return ;
8509   }
8510   {
8511     try {
8512       (arg1)->SetIdentityAndScale((Dali::Vector3 const &)*arg2);
8513     } CALL_CATCH_EXCEPTION();
8514   }
8515
8516 }
8517
8518
8519 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_InvertTransform(void * jarg1, void * jarg2) {
8520   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8521   Dali::Matrix *arg2 = 0 ;
8522
8523   arg1 = (Dali::Matrix *)jarg1;
8524   arg2 = (Dali::Matrix *)jarg2;
8525   if (!arg2) {
8526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
8527     return ;
8528   }
8529   {
8530     try {
8531       ((Dali::Matrix const *)arg1)->InvertTransform(*arg2);
8532     } CALL_CATCH_EXCEPTION();
8533   }
8534
8535 }
8536
8537
8538 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_Invert(void * jarg1) {
8539   unsigned int jresult ;
8540   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8541   bool result;
8542
8543   arg1 = (Dali::Matrix *)jarg1;
8544   {
8545     try {
8546       result = (bool)(arg1)->Invert();
8547     } CALL_CATCH_EXCEPTION(0);
8548   }
8549
8550   jresult = result;
8551   return jresult;
8552 }
8553
8554
8555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Transpose(void * jarg1) {
8556   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8557
8558   arg1 = (Dali::Matrix *)jarg1;
8559   {
8560     try {
8561       (arg1)->Transpose();
8562     } CALL_CATCH_EXCEPTION();
8563   }
8564
8565 }
8566
8567
8568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetXAxis(void * jarg1) {
8569   void * jresult ;
8570   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8571   Dali::Vector3 result;
8572
8573   arg1 = (Dali::Matrix *)jarg1;
8574   {
8575     try {
8576       result = ((Dali::Matrix const *)arg1)->GetXAxis();
8577     } CALL_CATCH_EXCEPTION(0);
8578   }
8579
8580   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
8581   return jresult;
8582 }
8583
8584
8585 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetYAxis(void * jarg1) {
8586   void * jresult ;
8587   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8588   Dali::Vector3 result;
8589
8590   arg1 = (Dali::Matrix *)jarg1;
8591   {
8592     try {
8593       result = ((Dali::Matrix const *)arg1)->GetYAxis();
8594     } CALL_CATCH_EXCEPTION(0);
8595   }
8596
8597   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
8598   return jresult;
8599 }
8600
8601
8602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetZAxis(void * jarg1) {
8603   void * jresult ;
8604   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8605   Dali::Vector3 result;
8606
8607   arg1 = (Dali::Matrix *)jarg1;
8608   {
8609     try {
8610       result = ((Dali::Matrix const *)arg1)->GetZAxis();
8611     } CALL_CATCH_EXCEPTION(0);
8612   }
8613
8614   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
8615   return jresult;
8616 }
8617
8618
8619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetXAxis(void * jarg1, void * jarg2) {
8620   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8621   Dali::Vector3 *arg2 = 0 ;
8622
8623   arg1 = (Dali::Matrix *)jarg1;
8624   arg2 = (Dali::Vector3 *)jarg2;
8625   if (!arg2) {
8626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8627     return ;
8628   }
8629   {
8630     try {
8631       (arg1)->SetXAxis((Dali::Vector3 const &)*arg2);
8632     } CALL_CATCH_EXCEPTION();
8633   }
8634
8635 }
8636
8637
8638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetYAxis(void * jarg1, void * jarg2) {
8639   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8640   Dali::Vector3 *arg2 = 0 ;
8641
8642   arg1 = (Dali::Matrix *)jarg1;
8643   arg2 = (Dali::Vector3 *)jarg2;
8644   if (!arg2) {
8645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8646     return ;
8647   }
8648   {
8649     try {
8650       (arg1)->SetYAxis((Dali::Vector3 const &)*arg2);
8651     } CALL_CATCH_EXCEPTION();
8652   }
8653
8654 }
8655
8656
8657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetZAxis(void * jarg1, void * jarg2) {
8658   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8659   Dali::Vector3 *arg2 = 0 ;
8660
8661   arg1 = (Dali::Matrix *)jarg1;
8662   arg2 = (Dali::Vector3 *)jarg2;
8663   if (!arg2) {
8664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8665     return ;
8666   }
8667   {
8668     try {
8669       (arg1)->SetZAxis((Dali::Vector3 const &)*arg2);
8670     } CALL_CATCH_EXCEPTION();
8671   }
8672
8673 }
8674
8675
8676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation(void * jarg1) {
8677   void * jresult ;
8678   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8679   Dali::Vector4 *result = 0 ;
8680
8681   arg1 = (Dali::Matrix *)jarg1;
8682   {
8683     try {
8684       result = (Dali::Vector4 *) &((Dali::Matrix const *)arg1)->GetTranslation();
8685     } CALL_CATCH_EXCEPTION(0);
8686   }
8687
8688   jresult = (void *)result;
8689   return jresult;
8690 }
8691
8692
8693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation3(void * jarg1) {
8694   void * jresult ;
8695   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8696   Dali::Vector3 *result = 0 ;
8697
8698   arg1 = (Dali::Matrix *)jarg1;
8699   {
8700     try {
8701       result = (Dali::Vector3 *) &((Dali::Matrix const *)arg1)->GetTranslation3();
8702     } CALL_CATCH_EXCEPTION(0);
8703   }
8704
8705   jresult = (void *)result;
8706   return jresult;
8707 }
8708
8709
8710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_0(void * jarg1, void * jarg2) {
8711   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8712   Dali::Vector4 *arg2 = 0 ;
8713
8714   arg1 = (Dali::Matrix *)jarg1;
8715   arg2 = (Dali::Vector4 *)jarg2;
8716   if (!arg2) {
8717     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8718     return ;
8719   }
8720   {
8721     try {
8722       (arg1)->SetTranslation((Dali::Vector4 const &)*arg2);
8723     } CALL_CATCH_EXCEPTION();
8724   }
8725
8726 }
8727
8728
8729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_1(void * jarg1, void * jarg2) {
8730   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8731   Dali::Vector3 *arg2 = 0 ;
8732
8733   arg1 = (Dali::Matrix *)jarg1;
8734   arg2 = (Dali::Vector3 *)jarg2;
8735   if (!arg2) {
8736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8737     return ;
8738   }
8739   {
8740     try {
8741       (arg1)->SetTranslation((Dali::Vector3 const &)*arg2);
8742     } CALL_CATCH_EXCEPTION();
8743   }
8744
8745 }
8746
8747
8748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_OrthoNormalize(void * jarg1) {
8749   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8750
8751   arg1 = (Dali::Matrix *)jarg1;
8752   {
8753     try {
8754       (arg1)->OrthoNormalize();
8755     } CALL_CATCH_EXCEPTION();
8756   }
8757
8758 }
8759
8760
8761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_AsFloat__SWIG_0(void * jarg1) {
8762   void * jresult ;
8763   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8764   float *result = 0 ;
8765
8766   arg1 = (Dali::Matrix *)jarg1;
8767   {
8768     try {
8769       result = (float *)((Dali::Matrix const *)arg1)->AsFloat();
8770     } CALL_CATCH_EXCEPTION(0);
8771   }
8772
8773   jresult = (void *)result;
8774   return jresult;
8775 }
8776
8777
8778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
8779   Dali::Matrix *arg1 = 0 ;
8780   Dali::Matrix *arg2 = 0 ;
8781   Dali::Matrix *arg3 = 0 ;
8782
8783   arg1 = (Dali::Matrix *)jarg1;
8784   if (!arg1) {
8785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
8786     return ;
8787   }
8788   arg2 = (Dali::Matrix *)jarg2;
8789   if (!arg2) {
8790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
8791     return ;
8792   }
8793   arg3 = (Dali::Matrix *)jarg3;
8794   if (!arg3) {
8795     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
8796     return ;
8797   }
8798   {
8799     try {
8800       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Matrix const &)*arg3);
8801     } CALL_CATCH_EXCEPTION();
8802   }
8803
8804 }
8805
8806
8807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
8808   Dali::Matrix *arg1 = 0 ;
8809   Dali::Matrix *arg2 = 0 ;
8810   Dali::Quaternion *arg3 = 0 ;
8811
8812   arg1 = (Dali::Matrix *)jarg1;
8813   if (!arg1) {
8814     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
8815     return ;
8816   }
8817   arg2 = (Dali::Matrix *)jarg2;
8818   if (!arg2) {
8819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
8820     return ;
8821   }
8822   arg3 = (Dali::Quaternion *)jarg3;
8823   if (!arg3) {
8824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
8825     return ;
8826   }
8827   {
8828     try {
8829       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Quaternion const &)*arg3);
8830     } CALL_CATCH_EXCEPTION();
8831   }
8832
8833 }
8834
8835
8836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_2(void * jarg1, void * jarg2) {
8837   void * jresult ;
8838   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8839   Dali::Vector4 *arg2 = 0 ;
8840   Dali::Vector4 result;
8841
8842   arg1 = (Dali::Matrix *)jarg1;
8843   arg2 = (Dali::Vector4 *)jarg2;
8844   if (!arg2) {
8845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8846     return 0;
8847   }
8848   {
8849     try {
8850       result = ((Dali::Matrix const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
8851     } CALL_CATCH_EXCEPTION(0);
8852   }
8853
8854   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8855   return jresult;
8856 }
8857
8858
8859 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_EqualTo(void * jarg1, void * jarg2) {
8860   unsigned int jresult ;
8861   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8862   Dali::Matrix *arg2 = 0 ;
8863   bool result;
8864
8865   arg1 = (Dali::Matrix *)jarg1;
8866   arg2 = (Dali::Matrix *)jarg2;
8867   if (!arg2) {
8868     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
8869     return 0;
8870   }
8871   {
8872     try {
8873       result = (bool)((Dali::Matrix const *)arg1)->operator ==((Dali::Matrix const &)*arg2);
8874     } CALL_CATCH_EXCEPTION(0);
8875   }
8876
8877   jresult = result;
8878   return jresult;
8879 }
8880
8881
8882 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_NotEqualTo(void * jarg1, void * jarg2) {
8883   unsigned int jresult ;
8884   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8885   Dali::Matrix *arg2 = 0 ;
8886   bool result;
8887
8888   arg1 = (Dali::Matrix *)jarg1;
8889   arg2 = (Dali::Matrix *)jarg2;
8890   if (!arg2) {
8891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
8892     return 0;
8893   }
8894   {
8895     try {
8896       result = (bool)((Dali::Matrix const *)arg1)->operator !=((Dali::Matrix const &)*arg2);
8897     } CALL_CATCH_EXCEPTION(0);
8898   }
8899
8900   jresult = result;
8901   return jresult;
8902 }
8903
8904
8905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
8906   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8907   Dali::Vector3 *arg2 = 0 ;
8908   Dali::Quaternion *arg3 = 0 ;
8909   Dali::Vector3 *arg4 = 0 ;
8910
8911   arg1 = (Dali::Matrix *)jarg1;
8912   arg2 = (Dali::Vector3 *)jarg2;
8913   if (!arg2) {
8914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8915     return ;
8916   }
8917   arg3 = (Dali::Quaternion *)jarg3;
8918   if (!arg3) {
8919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
8920     return ;
8921   }
8922   arg4 = (Dali::Vector3 *)jarg4;
8923   if (!arg4) {
8924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8925     return ;
8926   }
8927   {
8928     try {
8929       (arg1)->SetTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
8930     } CALL_CATCH_EXCEPTION();
8931   }
8932
8933 }
8934
8935
8936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
8937   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8938   Dali::Vector3 *arg2 = 0 ;
8939   Dali::Quaternion *arg3 = 0 ;
8940   Dali::Vector3 *arg4 = 0 ;
8941
8942   arg1 = (Dali::Matrix *)jarg1;
8943   arg2 = (Dali::Vector3 *)jarg2;
8944   if (!arg2) {
8945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8946     return ;
8947   }
8948   arg3 = (Dali::Quaternion *)jarg3;
8949   if (!arg3) {
8950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
8951     return ;
8952   }
8953   arg4 = (Dali::Vector3 *)jarg4;
8954   if (!arg4) {
8955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8956     return ;
8957   }
8958   {
8959     try {
8960       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
8961     } CALL_CATCH_EXCEPTION();
8962   }
8963
8964 }
8965
8966
8967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
8968   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
8969   Dali::Vector3 *arg2 = 0 ;
8970   Dali::Vector3 *arg3 = 0 ;
8971   Dali::Vector3 *arg4 = 0 ;
8972   Dali::Vector3 *arg5 = 0 ;
8973
8974   arg1 = (Dali::Matrix *)jarg1;
8975   arg2 = (Dali::Vector3 *)jarg2;
8976   if (!arg2) {
8977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8978     return ;
8979   }
8980   arg3 = (Dali::Vector3 *)jarg3;
8981   if (!arg3) {
8982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8983     return ;
8984   }
8985   arg4 = (Dali::Vector3 *)jarg4;
8986   if (!arg4) {
8987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8988     return ;
8989   }
8990   arg5 = (Dali::Vector3 *)jarg5;
8991   if (!arg5) {
8992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8993     return ;
8994   }
8995   {
8996     try {
8997       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3,(Dali::Vector3 const &)*arg4,(Dali::Vector3 const &)*arg5);
8998     } CALL_CATCH_EXCEPTION();
8999   }
9000
9001 }
9002
9003
9004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_GetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
9005   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
9006   Dali::Vector3 *arg2 = 0 ;
9007   Dali::Quaternion *arg3 = 0 ;
9008   Dali::Vector3 *arg4 = 0 ;
9009
9010   arg1 = (Dali::Matrix *)jarg1;
9011   arg2 = (Dali::Vector3 *)jarg2;
9012   if (!arg2) {
9013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
9014     return ;
9015   }
9016   arg3 = (Dali::Quaternion *)jarg3;
9017   if (!arg3) {
9018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
9019     return ;
9020   }
9021   arg4 = (Dali::Vector3 *)jarg4;
9022   if (!arg4) {
9023     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
9024     return ;
9025   }
9026   {
9027     try {
9028       ((Dali::Matrix const *)arg1)->GetTransformComponents(*arg2,*arg3,*arg4);
9029     } CALL_CATCH_EXCEPTION();
9030   }
9031
9032 }
9033
9034
9035 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix(void * jarg1) {
9036   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
9037
9038   arg1 = (Dali::Matrix *)jarg1;
9039   {
9040     try {
9041       delete arg1;
9042     } CALL_CATCH_EXCEPTION();
9043   }
9044
9045 }
9046
9047
9048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_IDENTITY_get() {
9049   void * jresult ;
9050   Dali::Matrix3 *result = 0 ;
9051
9052   result = (Dali::Matrix3 *)&Dali::Matrix3::IDENTITY;
9053   jresult = (void *)result;
9054   return jresult;
9055 }
9056
9057
9058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_0() {
9059   void * jresult ;
9060   Dali::Matrix3 *result = 0 ;
9061
9062   {
9063     try {
9064       result = (Dali::Matrix3 *)new Dali::Matrix3();
9065     } CALL_CATCH_EXCEPTION(0);
9066   }
9067
9068   jresult = (void *)result;
9069   return jresult;
9070 }
9071
9072
9073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_1(void * jarg1) {
9074   void * jresult ;
9075   Dali::Matrix3 *arg1 = 0 ;
9076   Dali::Matrix3 *result = 0 ;
9077
9078   arg1 = (Dali::Matrix3 *)jarg1;
9079   if (!arg1) {
9080     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
9081     return 0;
9082   }
9083   {
9084     try {
9085       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix3 const &)*arg1);
9086     } CALL_CATCH_EXCEPTION(0);
9087   }
9088
9089   jresult = (void *)result;
9090   return jresult;
9091 }
9092
9093
9094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_2(void * jarg1) {
9095   void * jresult ;
9096   Dali::Matrix *arg1 = 0 ;
9097   Dali::Matrix3 *result = 0 ;
9098
9099   arg1 = (Dali::Matrix *)jarg1;
9100   if (!arg1) {
9101     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
9102     return 0;
9103   }
9104   {
9105     try {
9106       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix const &)*arg1);
9107     } CALL_CATCH_EXCEPTION(0);
9108   }
9109
9110   jresult = (void *)result;
9111   return jresult;
9112 }
9113
9114
9115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_3(float jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7, float jarg8, float jarg9) {
9116   void * jresult ;
9117   float arg1 ;
9118   float arg2 ;
9119   float arg3 ;
9120   float arg4 ;
9121   float arg5 ;
9122   float arg6 ;
9123   float arg7 ;
9124   float arg8 ;
9125   float arg9 ;
9126   Dali::Matrix3 *result = 0 ;
9127
9128   arg1 = (float)jarg1;
9129   arg2 = (float)jarg2;
9130   arg3 = (float)jarg3;
9131   arg4 = (float)jarg4;
9132   arg5 = (float)jarg5;
9133   arg6 = (float)jarg6;
9134   arg7 = (float)jarg7;
9135   arg8 = (float)jarg8;
9136   arg9 = (float)jarg9;
9137   {
9138     try {
9139       result = (Dali::Matrix3 *)new Dali::Matrix3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
9140     } CALL_CATCH_EXCEPTION(0);
9141   }
9142
9143   jresult = (void *)result;
9144   return jresult;
9145 }
9146
9147
9148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_0(void * jarg1, void * jarg2) {
9149   void * jresult ;
9150   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
9151   Dali::Matrix3 *arg2 = 0 ;
9152   Dali::Matrix3 *result = 0 ;
9153
9154   arg1 = (Dali::Matrix3 *)jarg1;
9155   arg2 = (Dali::Matrix3 *)jarg2;
9156   if (!arg2) {
9157     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
9158     return 0;
9159   }
9160   {
9161     try {
9162       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix3 const &)*arg2);
9163     } CALL_CATCH_EXCEPTION(0);
9164   }
9165
9166   jresult = (void *)result;
9167   return jresult;
9168 }
9169
9170
9171 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_1(void * jarg1, void * jarg2) {
9172   void * jresult ;
9173   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
9174   Dali::Matrix *arg2 = 0 ;
9175   Dali::Matrix3 *result = 0 ;
9176
9177   arg1 = (Dali::Matrix3 *)jarg1;
9178   arg2 = (Dali::Matrix *)jarg2;
9179   if (!arg2) {
9180     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
9181     return 0;
9182   }
9183   {
9184     try {
9185       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
9186     } CALL_CATCH_EXCEPTION(0);
9187   }
9188
9189   jresult = (void *)result;
9190   return jresult;
9191 }
9192
9193
9194 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_EqualTo(void * jarg1, void * jarg2) {
9195   unsigned int jresult ;
9196   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
9197   Dali::Matrix3 *arg2 = 0 ;
9198   bool result;
9199
9200   arg1 = (Dali::Matrix3 *)jarg1;
9201   arg2 = (Dali::Matrix3 *)jarg2;
9202   if (!arg2) {
9203     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
9204     return 0;
9205   }
9206   {
9207     try {
9208       result = (bool)((Dali::Matrix3 const *)arg1)->operator ==((Dali::Matrix3 const &)*arg2);
9209     } CALL_CATCH_EXCEPTION(0);
9210   }
9211
9212   jresult = result;
9213   return jresult;
9214 }
9215
9216
9217 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_NotEqualTo(void * jarg1, void * jarg2) {
9218   unsigned int jresult ;
9219   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
9220   Dali::Matrix3 *arg2 = 0 ;
9221   bool result;
9222
9223   arg1 = (Dali::Matrix3 *)jarg1;
9224   arg2 = (Dali::Matrix3 *)jarg2;
9225   if (!arg2) {
9226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
9227     return 0;
9228   }
9229   {
9230     try {
9231       result = (bool)((Dali::Matrix3 const *)arg1)->operator !=((Dali::Matrix3 const &)*arg2);
9232     } CALL_CATCH_EXCEPTION(0);
9233   }
9234
9235   jresult = result;
9236   return jresult;
9237 }
9238
9239
9240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix3(void * jarg1) {
9241   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
9242
9243   arg1 = (Dali::Matrix3 *)jarg1;
9244   {
9245     try {
9246       delete arg1;
9247     } CALL_CATCH_EXCEPTION();
9248   }
9249
9250 }
9251
9252
9253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetIdentity(void * jarg1) {
9254   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
9255
9256   arg1 = (Dali::Matrix3 *)jarg1;
9257   {
9258     try {
9259       (arg1)->SetIdentity();
9260     } CALL_CATCH_EXCEPTION();
9261   }
9262
9263 }
9264
9265
9266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_AsFloat__SWIG_0(void * jarg1) {
9267   void * jresult ;
9268   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
9269   float *result = 0 ;
9270
9271   arg1 = (Dali::Matrix3 *)jarg1;
9272   {
9273     try {
9274       result = (float *)((Dali::Matrix3 const *)arg1)->AsFloat();
9275     } CALL_CATCH_EXCEPTION(0);
9276   }
9277
9278   jresult = (void *)result;
9279   return jresult;
9280 }
9281
9282
9283 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Invert(void * jarg1) {
9284   unsigned int jresult ;
9285   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
9286   bool result;
9287
9288   arg1 = (Dali::Matrix3 *)jarg1;
9289   {
9290     try {
9291       result = (bool)(arg1)->Invert();
9292     } CALL_CATCH_EXCEPTION(0);
9293   }
9294
9295   jresult = result;
9296   return jresult;
9297 }
9298
9299
9300 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Transpose(void * jarg1) {
9301   unsigned int jresult ;
9302   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
9303   bool result;
9304
9305   arg1 = (Dali::Matrix3 *)jarg1;
9306   {
9307     try {
9308       result = (bool)(arg1)->Transpose();
9309     } CALL_CATCH_EXCEPTION(0);
9310   }
9311
9312   jresult = result;
9313   return jresult;
9314 }
9315
9316
9317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Scale(void * jarg1, float jarg2) {
9318   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
9319   float arg2 ;
9320
9321   arg1 = (Dali::Matrix3 *)jarg1;
9322   arg2 = (float)jarg2;
9323   {
9324     try {
9325       (arg1)->Scale(arg2);
9326     } CALL_CATCH_EXCEPTION();
9327   }
9328
9329 }
9330
9331
9332 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_Magnitude(void * jarg1) {
9333   float jresult ;
9334   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
9335   float result;
9336
9337   arg1 = (Dali::Matrix3 *)jarg1;
9338   {
9339     try {
9340       result = (float)((Dali::Matrix3 const *)arg1)->Magnitude();
9341     } CALL_CATCH_EXCEPTION(0);
9342   }
9343
9344   jresult = result;
9345   return jresult;
9346 }
9347
9348
9349 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_ScaledInverseTranspose(void * jarg1) {
9350   unsigned int jresult ;
9351   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
9352   bool result;
9353
9354   arg1 = (Dali::Matrix3 *)jarg1;
9355   {
9356     try {
9357       result = (bool)(arg1)->ScaledInverseTranspose();
9358     } CALL_CATCH_EXCEPTION(0);
9359   }
9360
9361   jresult = result;
9362   return jresult;
9363 }
9364
9365
9366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Multiply(void * jarg1, void * jarg2, void * jarg3) {
9367   Dali::Matrix3 *arg1 = 0 ;
9368   Dali::Matrix3 *arg2 = 0 ;
9369   Dali::Matrix3 *arg3 = 0 ;
9370
9371   arg1 = (Dali::Matrix3 *)jarg1;
9372   if (!arg1) {
9373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
9374     return ;
9375   }
9376   arg2 = (Dali::Matrix3 *)jarg2;
9377   if (!arg2) {
9378     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
9379     return ;
9380   }
9381   arg3 = (Dali::Matrix3 *)jarg3;
9382   if (!arg3) {
9383     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
9384     return ;
9385   }
9386   {
9387     try {
9388       Dali::Matrix3::Multiply(*arg1,(Dali::Matrix3 const &)*arg2,(Dali::Matrix3 const &)*arg3);
9389     } CALL_CATCH_EXCEPTION();
9390   }
9391
9392 }
9393
9394
9395 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Range(float jarg1, float jarg2) {
9396   float jresult ;
9397   float arg1 ;
9398   float arg2 ;
9399   float result;
9400
9401   arg1 = (float)jarg1;
9402   arg2 = (float)jarg2;
9403   {
9404     try {
9405       result = (float)Dali::Random::Range(arg1,arg2);
9406     } CALL_CATCH_EXCEPTION(0);
9407   }
9408
9409   jresult = result;
9410   return jresult;
9411 }
9412
9413
9414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Axis() {
9415   void * jresult ;
9416   Dali::Vector4 result;
9417
9418   {
9419     try {
9420       result = Dali::Random::Axis();
9421     } CALL_CATCH_EXCEPTION(0);
9422   }
9423
9424   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
9425   return jresult;
9426 }
9427
9428
9429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_0() {
9430   void * jresult ;
9431   Dali::AngleAxis *result = 0 ;
9432
9433   {
9434     try {
9435       result = (Dali::AngleAxis *)new Dali::AngleAxis();
9436     } CALL_CATCH_EXCEPTION(0);
9437   }
9438
9439   jresult = (void *)result;
9440   return jresult;
9441 }
9442
9443
9444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_1(void * jarg1, void * jarg2) {
9445   void * jresult ;
9446   Dali::Radian arg1 ;
9447   Dali::Vector3 *arg2 = 0 ;
9448   Dali::Radian *argp1 ;
9449   Dali::AngleAxis *result = 0 ;
9450
9451   argp1 = (Dali::Radian *)jarg1;
9452   if (!argp1) {
9453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9454     return 0;
9455   }
9456   arg1 = *argp1;
9457   arg2 = (Dali::Vector3 *)jarg2;
9458   if (!arg2) {
9459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
9460     return 0;
9461   }
9462   {
9463     try {
9464       result = (Dali::AngleAxis *)new Dali::AngleAxis(arg1,(Dali::Vector3 const &)*arg2);
9465     } CALL_CATCH_EXCEPTION(0);
9466   }
9467
9468   jresult = (void *)result;
9469   return jresult;
9470 }
9471
9472
9473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_angle_set(void * jarg1, void * jarg2) {
9474   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
9475   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
9476
9477   arg1 = (Dali::AngleAxis *)jarg1;
9478   arg2 = (Dali::Radian *)jarg2;
9479   if (arg1) (arg1)->angle = *arg2;
9480 }
9481
9482
9483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_angle_get(void * jarg1) {
9484   void * jresult ;
9485   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
9486   Dali::Radian *result = 0 ;
9487
9488   arg1 = (Dali::AngleAxis *)jarg1;
9489   result = (Dali::Radian *)& ((arg1)->angle);
9490   jresult = (void *)result;
9491   return jresult;
9492 }
9493
9494
9495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_axis_set(void * jarg1, void * jarg2) {
9496   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
9497   Dali::Vector3 *arg2 = (Dali::Vector3 *) 0 ;
9498
9499   arg1 = (Dali::AngleAxis *)jarg1;
9500   arg2 = (Dali::Vector3 *)jarg2;
9501   if (arg1) (arg1)->axis = *arg2;
9502 }
9503
9504
9505 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_axis_get(void * jarg1) {
9506   void * jresult ;
9507   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
9508   Dali::Vector3 *result = 0 ;
9509
9510   arg1 = (Dali::AngleAxis *)jarg1;
9511   result = (Dali::Vector3 *)& ((arg1)->axis);
9512   jresult = (void *)result;
9513   return jresult;
9514 }
9515
9516
9517 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleAxis(void * jarg1) {
9518   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
9519
9520   arg1 = (Dali::AngleAxis *)jarg1;
9521   {
9522     try {
9523       delete arg1;
9524     } CALL_CATCH_EXCEPTION();
9525   }
9526
9527 }
9528
9529
9530 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_9(void * jarg1, void * jarg2) {
9531   unsigned int jresult ;
9532   Dali::AngleAxis *arg1 = 0 ;
9533   Dali::AngleAxis *arg2 = 0 ;
9534   bool result;
9535
9536   arg1 = (Dali::AngleAxis *)jarg1;
9537   if (!arg1) {
9538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
9539     return 0;
9540   }
9541   arg2 = (Dali::AngleAxis *)jarg2;
9542   if (!arg2) {
9543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
9544     return 0;
9545   }
9546   {
9547     try {
9548       result = (bool)Dali::operator ==((Dali::AngleAxis const &)*arg1,(Dali::AngleAxis const &)*arg2);
9549     } CALL_CATCH_EXCEPTION(0);
9550   }
9551
9552   jresult = result;
9553   return jresult;
9554 }
9555
9556
9557 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NextPowerOfTwo(unsigned int jarg1) {
9558   unsigned int jresult ;
9559   unsigned int arg1 ;
9560   unsigned int result;
9561
9562   arg1 = (unsigned int)jarg1;
9563   {
9564     try {
9565       result = (unsigned int)Dali::NextPowerOfTwo(arg1);
9566     } CALL_CATCH_EXCEPTION(0);
9567   }
9568
9569   jresult = result;
9570   return jresult;
9571 }
9572
9573
9574 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsPowerOfTwo(unsigned int jarg1) {
9575   unsigned int jresult ;
9576   unsigned int arg1 ;
9577   bool result;
9578
9579   arg1 = (unsigned int)jarg1;
9580   {
9581     try {
9582       result = (bool)Dali::IsPowerOfTwo(arg1);
9583     } CALL_CATCH_EXCEPTION(0);
9584   }
9585
9586   jresult = result;
9587   return jresult;
9588 }
9589
9590
9591 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GetRangedEpsilon(float jarg1, float jarg2) {
9592   float jresult ;
9593   float arg1 ;
9594   float arg2 ;
9595   float result;
9596
9597   arg1 = (float)jarg1;
9598   arg2 = (float)jarg2;
9599   {
9600     try {
9601       result = (float)Dali::GetRangedEpsilon(arg1,arg2);
9602     } CALL_CATCH_EXCEPTION(0);
9603   }
9604
9605   jresult = result;
9606   return jresult;
9607 }
9608
9609
9610 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualsZero(float jarg1) {
9611   unsigned int jresult ;
9612   float arg1 ;
9613   bool result;
9614
9615   arg1 = (float)jarg1;
9616   {
9617     try {
9618       result = (bool)Dali::EqualsZero(arg1);
9619     } CALL_CATCH_EXCEPTION(0);
9620   }
9621
9622   jresult = result;
9623   return jresult;
9624 }
9625
9626
9627 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_0(float jarg1, float jarg2) {
9628   unsigned int jresult ;
9629   float arg1 ;
9630   float arg2 ;
9631   bool result;
9632
9633   arg1 = (float)jarg1;
9634   arg2 = (float)jarg2;
9635   {
9636     try {
9637       result = (bool)Dali::Equals(arg1,arg2);
9638     } CALL_CATCH_EXCEPTION(0);
9639   }
9640
9641   jresult = result;
9642   return jresult;
9643 }
9644
9645
9646 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_1(float jarg1, float jarg2, float jarg3) {
9647   unsigned int jresult ;
9648   float arg1 ;
9649   float arg2 ;
9650   float arg3 ;
9651   bool result;
9652
9653   arg1 = (float)jarg1;
9654   arg2 = (float)jarg2;
9655   arg3 = (float)jarg3;
9656   {
9657     try {
9658       result = (bool)Dali::Equals(arg1,arg2,arg3);
9659     } CALL_CATCH_EXCEPTION(0);
9660   }
9661
9662   jresult = result;
9663   return jresult;
9664 }
9665
9666
9667 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Round(float jarg1, int jarg2) {
9668   float jresult ;
9669   float arg1 ;
9670   int arg2 ;
9671   float result;
9672
9673   arg1 = (float)jarg1;
9674   arg2 = (int)jarg2;
9675   {
9676     try {
9677       result = (float)Dali::Round(arg1,arg2);
9678     } CALL_CATCH_EXCEPTION(0);
9679   }
9680
9681   jresult = result;
9682   return jresult;
9683 }
9684
9685
9686 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_WrapInDomain(float jarg1, float jarg2, float jarg3) {
9687   float jresult ;
9688   float arg1 ;
9689   float arg2 ;
9690   float arg3 ;
9691   float result;
9692
9693   arg1 = (float)jarg1;
9694   arg2 = (float)jarg2;
9695   arg3 = (float)jarg3;
9696   {
9697     try {
9698       result = (float)Dali::WrapInDomain(arg1,arg2,arg3);
9699     } CALL_CATCH_EXCEPTION(0);
9700   }
9701
9702   jresult = result;
9703   return jresult;
9704 }
9705
9706
9707 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ShortestDistanceInDomain(float jarg1, float jarg2, float jarg3, float jarg4) {
9708   float jresult ;
9709   float arg1 ;
9710   float arg2 ;
9711   float arg3 ;
9712   float arg4 ;
9713   float result;
9714
9715   arg1 = (float)jarg1;
9716   arg2 = (float)jarg2;
9717   arg3 = (float)jarg3;
9718   arg4 = (float)jarg4;
9719   {
9720     try {
9721       result = (float)Dali::ShortestDistanceInDomain(arg1,arg2,arg3,arg4);
9722     } CALL_CATCH_EXCEPTION(0);
9723   }
9724
9725   jresult = result;
9726   return jresult;
9727 }
9728
9729
9730 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_INDEX_get() {
9731   int jresult ;
9732   int result;
9733
9734   result = (int)(int)Dali::Property::INVALID_INDEX;
9735   jresult = result;
9736   return jresult;
9737 }
9738
9739
9740 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_KEY_get() {
9741   int jresult ;
9742   int result;
9743
9744   result = (int)(int)Dali::Property::INVALID_KEY;
9745   jresult = result;
9746   return jresult;
9747 }
9748
9749
9750 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_COMPONENT_INDEX_get() {
9751   int jresult ;
9752   int result;
9753
9754   result = (int)(int)Dali::Property::INVALID_COMPONENT_INDEX;
9755   jresult = result;
9756   return jresult;
9757 }
9758
9759
9760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_0(void * jarg1, int jarg2) {
9761   void * jresult ;
9762   Dali::Handle *arg1 = 0 ;
9763   Dali::Property::Index arg2 ;
9764   Dali::Property *result = 0 ;
9765
9766   arg1 = (Dali::Handle *)jarg1;
9767   if (!arg1) {
9768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
9769     return 0;
9770   }
9771   arg2 = (Dali::Property::Index)jarg2;
9772   {
9773     try {
9774       result = (Dali::Property *)new Dali::Property(*arg1,arg2);
9775     } CALL_CATCH_EXCEPTION(0);
9776   }
9777
9778   jresult = (void *)result;
9779   return jresult;
9780 }
9781
9782
9783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_1(void * jarg1, int jarg2, int jarg3) {
9784   void * jresult ;
9785   Dali::Handle *arg1 = 0 ;
9786   Dali::Property::Index arg2 ;
9787   int arg3 ;
9788   Dali::Property *result = 0 ;
9789
9790   arg1 = (Dali::Handle *)jarg1;
9791   if (!arg1) {
9792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
9793     return 0;
9794   }
9795   arg2 = (Dali::Property::Index)jarg2;
9796   arg3 = (int)jarg3;
9797   {
9798     try {
9799       result = (Dali::Property *)new Dali::Property(*arg1,arg2,arg3);
9800     } CALL_CATCH_EXCEPTION(0);
9801   }
9802
9803   jresult = (void *)result;
9804   return jresult;
9805 }
9806
9807
9808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_2(void * jarg1, char * jarg2) {
9809   void * jresult ;
9810   Dali::Handle *arg1 = 0 ;
9811   std::string *arg2 = 0 ;
9812   Dali::Property *result = 0 ;
9813
9814   arg1 = (Dali::Handle *)jarg1;
9815   if (!arg1) {
9816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
9817     return 0;
9818   }
9819   if (!jarg2) {
9820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
9821     return 0;
9822   }
9823   std::string arg2_str(jarg2);
9824   arg2 = &arg2_str;
9825   {
9826     try {
9827       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2);
9828     } CALL_CATCH_EXCEPTION(0);
9829   }
9830
9831   jresult = (void *)result;
9832
9833   //argout typemap for const std::string&
9834
9835   return jresult;
9836 }
9837
9838
9839 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_3(void * jarg1, char * jarg2, int jarg3) {
9840   void * jresult ;
9841   Dali::Handle *arg1 = 0 ;
9842   std::string *arg2 = 0 ;
9843   int arg3 ;
9844   Dali::Property *result = 0 ;
9845
9846   arg1 = (Dali::Handle *)jarg1;
9847   if (!arg1) {
9848     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
9849     return 0;
9850   }
9851   if (!jarg2) {
9852     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
9853     return 0;
9854   }
9855   std::string arg2_str(jarg2);
9856   arg2 = &arg2_str;
9857   arg3 = (int)jarg3;
9858   {
9859     try {
9860       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2,arg3);
9861     } CALL_CATCH_EXCEPTION(0);
9862   }
9863
9864   jresult = (void *)result;
9865
9866   //argout typemap for const std::string&
9867
9868   return jresult;
9869 }
9870
9871
9872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property(void * jarg1) {
9873   Dali::Property *arg1 = (Dali::Property *) 0 ;
9874
9875   arg1 = (Dali::Property *)jarg1;
9876   {
9877     try {
9878       delete arg1;
9879     } CALL_CATCH_EXCEPTION();
9880   }
9881
9882 }
9883
9884
9885 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property__object_set(void * jarg1, void * jarg2) {
9886   Dali::Property *arg1 = (Dali::Property *) 0 ;
9887   Dali::Handle *arg2 = 0 ;
9888
9889   arg1 = (Dali::Property *)jarg1;
9890   arg2 = (Dali::Handle *)jarg2;
9891   if (!arg2) {
9892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
9893     return ;
9894   }
9895   if (arg1) (arg1)->object = *arg2;
9896 }
9897
9898
9899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property__object_get(void * jarg1) {
9900   void * jresult ;
9901   Dali::Property *arg1 = (Dali::Property *) 0 ;
9902   Dali::Handle *result = 0 ;
9903
9904   arg1 = (Dali::Property *)jarg1;
9905   result = (Dali::Handle *) &(Dali::Handle &) ((arg1)->object);
9906   jresult = (void *)result;
9907   return jresult;
9908 }
9909
9910
9911 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_propertyIndex_set(void * jarg1, int jarg2) {
9912   Dali::Property *arg1 = (Dali::Property *) 0 ;
9913   Dali::Property::Index arg2 ;
9914
9915   arg1 = (Dali::Property *)jarg1;
9916   arg2 = (Dali::Property::Index)jarg2;
9917   if (arg1) (arg1)->propertyIndex = arg2;
9918 }
9919
9920
9921 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_propertyIndex_get(void * jarg1) {
9922   int jresult ;
9923   Dali::Property *arg1 = (Dali::Property *) 0 ;
9924   Dali::Property::Index result;
9925
9926   arg1 = (Dali::Property *)jarg1;
9927   result = (Dali::Property::Index) ((arg1)->propertyIndex);
9928   jresult = result;
9929   return jresult;
9930 }
9931
9932
9933 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_componentIndex_set(void * jarg1, int jarg2) {
9934   Dali::Property *arg1 = (Dali::Property *) 0 ;
9935   int arg2 ;
9936
9937   arg1 = (Dali::Property *)jarg1;
9938   arg2 = (int)jarg2;
9939   if (arg1) (arg1)->componentIndex = arg2;
9940 }
9941
9942
9943 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_componentIndex_get(void * jarg1) {
9944   int jresult ;
9945   Dali::Property *arg1 = (Dali::Property *) 0 ;
9946   int result;
9947
9948   arg1 = (Dali::Property *)jarg1;
9949   result = (int) ((arg1)->componentIndex);
9950   jresult = result;
9951   return jresult;
9952 }
9953
9954
9955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_0() {
9956   void * jresult ;
9957   Dali::Property::Array *result = 0 ;
9958
9959   {
9960     try {
9961       result = (Dali::Property::Array *)new Dali::Property::Array();
9962     } CALL_CATCH_EXCEPTION(0);
9963   }
9964
9965   jresult = (void *)result;
9966   return jresult;
9967 }
9968
9969
9970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_1(void * jarg1) {
9971   void * jresult ;
9972   Dali::Property::Array *arg1 = 0 ;
9973   Dali::Property::Array *result = 0 ;
9974
9975   arg1 = (Dali::Property::Array *)jarg1;
9976   if (!arg1) {
9977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
9978     return 0;
9979   }
9980   {
9981     try {
9982       result = (Dali::Property::Array *)new Dali::Property::Array((Dali::Property::Array const &)*arg1);
9983     } CALL_CATCH_EXCEPTION(0);
9984   }
9985
9986   jresult = (void *)result;
9987   return jresult;
9988 }
9989
9990
9991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Array(void * jarg1) {
9992   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
9993
9994   arg1 = (Dali::Property::Array *)jarg1;
9995   {
9996     try {
9997       delete arg1;
9998     } CALL_CATCH_EXCEPTION();
9999   }
10000
10001 }
10002
10003
10004 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Size(void * jarg1) {
10005   unsigned long jresult ;
10006   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
10007   Dali::Property::Array::SizeType result;
10008
10009   arg1 = (Dali::Property::Array *)jarg1;
10010   {
10011     try {
10012       result = ((Dali::Property::Array const *)arg1)->Size();
10013     } CALL_CATCH_EXCEPTION(0);
10014   }
10015
10016   jresult = (unsigned long)result;
10017   return jresult;
10018 }
10019
10020
10021 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Count(void * jarg1) {
10022   unsigned long jresult ;
10023   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
10024   Dali::Property::Array::SizeType result;
10025
10026   arg1 = (Dali::Property::Array *)jarg1;
10027   {
10028     try {
10029       result = ((Dali::Property::Array const *)arg1)->Count();
10030     } CALL_CATCH_EXCEPTION(0);
10031   }
10032
10033   jresult = (unsigned long)result;
10034   return jresult;
10035 }
10036
10037
10038 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Array_Empty(void * jarg1) {
10039   unsigned int jresult ;
10040   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
10041   bool result;
10042
10043   arg1 = (Dali::Property::Array *)jarg1;
10044   {
10045     try {
10046       result = (bool)((Dali::Property::Array const *)arg1)->Empty();
10047     } CALL_CATCH_EXCEPTION(0);
10048   }
10049
10050   jresult = result;
10051   return jresult;
10052 }
10053
10054
10055 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Clear(void * jarg1) {
10056   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
10057
10058   arg1 = (Dali::Property::Array *)jarg1;
10059   {
10060     try {
10061       (arg1)->Clear();
10062     } CALL_CATCH_EXCEPTION();
10063   }
10064
10065 }
10066
10067
10068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Reserve(void * jarg1, unsigned long jarg2) {
10069   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
10070   Dali::Property::Array::SizeType arg2 ;
10071
10072   arg1 = (Dali::Property::Array *)jarg1;
10073   arg2 = (Dali::Property::Array::SizeType)jarg2;
10074   {
10075     try {
10076       (arg1)->Reserve(arg2);
10077     } CALL_CATCH_EXCEPTION();
10078   }
10079
10080 }
10081
10082
10083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Resize(void * jarg1, unsigned long jarg2) {
10084   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
10085   Dali::Property::Array::SizeType arg2 ;
10086
10087   arg1 = (Dali::Property::Array *)jarg1;
10088   arg2 = (Dali::Property::Array::SizeType)jarg2;
10089   {
10090     try {
10091       (arg1)->Resize(arg2);
10092     } CALL_CATCH_EXCEPTION();
10093   }
10094
10095 }
10096
10097
10098 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Capacity(void * jarg1) {
10099   unsigned long jresult ;
10100   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
10101   Dali::Property::Array::SizeType result;
10102
10103   arg1 = (Dali::Property::Array *)jarg1;
10104   {
10105     try {
10106       result = (arg1)->Capacity();
10107     } CALL_CATCH_EXCEPTION(0);
10108   }
10109
10110   jresult = (unsigned long)result;
10111   return jresult;
10112 }
10113
10114
10115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_PushBack(void * jarg1, void * jarg2) {
10116   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
10117   Dali::Property::Value *arg2 = 0 ;
10118
10119   arg1 = (Dali::Property::Array *)jarg1;
10120   arg2 = (Dali::Property::Value *)jarg2;
10121   if (!arg2) {
10122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
10123     return ;
10124   }
10125   {
10126     try {
10127       (arg1)->PushBack((Dali::Property::Value const &)*arg2);
10128     } CALL_CATCH_EXCEPTION();
10129   }
10130
10131 }
10132
10133
10134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Add(void * jarg1, void * jarg2) {
10135   void * jresult ;
10136   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
10137   Dali::Property::Value *arg2 = 0 ;
10138   Dali::Property::Array *result = 0 ;
10139
10140   arg1 = (Dali::Property::Array *)jarg1;
10141   arg2 = (Dali::Property::Value *)jarg2;
10142   if (!arg2) {
10143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
10144     return 0;
10145   }
10146   {
10147     try {
10148       result = (Dali::Property::Array *) &(arg1)->Add((Dali::Property::Value const &)*arg2);
10149     } CALL_CATCH_EXCEPTION(0);
10150   }
10151
10152   jresult = (void *)result;
10153   return jresult;
10154 }
10155
10156
10157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_GetElementAt__SWIG_0(void * jarg1, unsigned long jarg2) {
10158   void * jresult ;
10159   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
10160   Dali::Property::Array::SizeType arg2 ;
10161   Dali::Property::Value *result = 0 ;
10162
10163   arg1 = (Dali::Property::Array *)jarg1;
10164   arg2 = (Dali::Property::Array::SizeType)jarg2;
10165   {
10166     try {
10167       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->GetElementAt(arg2);
10168     } CALL_CATCH_EXCEPTION(0);
10169   }
10170
10171   jresult = (void *)result;
10172   return jresult;
10173 }
10174
10175
10176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
10177   void * jresult ;
10178   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
10179   Dali::Property::Array::SizeType arg2 ;
10180   Dali::Property::Value *result = 0 ;
10181
10182   arg1 = (Dali::Property::Array *)jarg1;
10183   arg2 = (Dali::Property::Array::SizeType)jarg2;
10184   {
10185     try {
10186       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->operator [](arg2);
10187     } CALL_CATCH_EXCEPTION(0);
10188   }
10189
10190   jresult = (void *)result;
10191   return jresult;
10192 }
10193
10194
10195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Assign(void * jarg1, void * jarg2) {
10196   void * jresult ;
10197   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
10198   Dali::Property::Array *arg2 = 0 ;
10199   Dali::Property::Array *result = 0 ;
10200
10201   arg1 = (Dali::Property::Array *)jarg1;
10202   arg2 = (Dali::Property::Array *)jarg2;
10203   if (!arg2) {
10204     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
10205     return 0;
10206   }
10207   {
10208     try {
10209       result = (Dali::Property::Array *) &(arg1)->operator =((Dali::Property::Array const &)*arg2);
10210     } CALL_CATCH_EXCEPTION(0);
10211   }
10212
10213   jresult = (void *)result;
10214   return jresult;
10215 }
10216
10217
10218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_type_set(void * jarg1, int jarg2) {
10219   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
10220   enum Dali::Property::Key::Type arg2 ;
10221
10222   arg1 = (Dali::Property::Key *)jarg1;
10223   arg2 = (enum Dali::Property::Key::Type)jarg2;
10224   if (arg1) (arg1)->type = arg2;
10225 }
10226
10227
10228 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_type_get(void * jarg1) {
10229   int jresult ;
10230   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
10231   enum Dali::Property::Key::Type result;
10232
10233   arg1 = (Dali::Property::Key *)jarg1;
10234   result = (enum Dali::Property::Key::Type) ((arg1)->type);
10235   jresult = (int)result;
10236   return jresult;
10237 }
10238
10239
10240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_set(void * jarg1, int jarg2) {
10241   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
10242   Dali::Property::Index arg2 ;
10243
10244   arg1 = (Dali::Property::Key *)jarg1;
10245   arg2 = (Dali::Property::Index)jarg2;
10246   if (arg1) (arg1)->indexKey = arg2;
10247 }
10248
10249
10250 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_get(void * jarg1) {
10251   int jresult ;
10252   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
10253   Dali::Property::Index result;
10254
10255   arg1 = (Dali::Property::Key *)jarg1;
10256   result = (Dali::Property::Index) ((arg1)->indexKey);
10257   jresult = result;
10258   return jresult;
10259 }
10260
10261
10262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_set(void * jarg1, char * jarg2) {
10263   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
10264   std::string *arg2 = 0 ;
10265
10266   arg1 = (Dali::Property::Key *)jarg1;
10267   if (!jarg2) {
10268     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10269     return ;
10270   }
10271   std::string arg2_str(jarg2);
10272   arg2 = &arg2_str;
10273   if (arg1) (arg1)->stringKey = *arg2;
10274
10275   //argout typemap for const std::string&
10276
10277 }
10278
10279
10280 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_get(void * jarg1) {
10281   char * jresult ;
10282   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
10283   std::string *result = 0 ;
10284
10285   arg1 = (Dali::Property::Key *)jarg1;
10286   result = (std::string *) & ((arg1)->stringKey);
10287   jresult = SWIG_csharp_string_callback(result->c_str());
10288   return jresult;
10289 }
10290
10291
10292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_0(char * jarg1) {
10293   void * jresult ;
10294   std::string *arg1 = 0 ;
10295   Dali::Property::Key *result = 0 ;
10296
10297   if (!jarg1) {
10298     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10299     return 0;
10300   }
10301   std::string arg1_str(jarg1);
10302   arg1 = &arg1_str;
10303   {
10304     try {
10305       result = (Dali::Property::Key *)new Dali::Property::Key((std::string const &)*arg1);
10306     } CALL_CATCH_EXCEPTION(0);
10307   }
10308
10309   jresult = (void *)result;
10310
10311   //argout typemap for const std::string&
10312
10313   return jresult;
10314 }
10315
10316
10317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_1(int jarg1) {
10318   void * jresult ;
10319   Dali::Property::Index arg1 ;
10320   Dali::Property::Key *result = 0 ;
10321
10322   arg1 = (Dali::Property::Index)jarg1;
10323   {
10324     try {
10325       result = (Dali::Property::Key *)new Dali::Property::Key(arg1);
10326     } CALL_CATCH_EXCEPTION(0);
10327   }
10328
10329   jresult = (void *)result;
10330   return jresult;
10331 }
10332
10333
10334 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_0(void * jarg1, char * jarg2) {
10335   unsigned int jresult ;
10336   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
10337   std::string *arg2 = 0 ;
10338   bool result;
10339
10340   arg1 = (Dali::Property::Key *)jarg1;
10341   if (!jarg2) {
10342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10343     return 0;
10344   }
10345   std::string arg2_str(jarg2);
10346   arg2 = &arg2_str;
10347   {
10348     try {
10349       result = (bool)(arg1)->operator ==((std::string const &)*arg2);
10350     } CALL_CATCH_EXCEPTION(0);
10351   }
10352
10353   jresult = result;
10354
10355   //argout typemap for const std::string&
10356
10357   return jresult;
10358 }
10359
10360
10361 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_1(void * jarg1, int jarg2) {
10362   unsigned int jresult ;
10363   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
10364   Dali::Property::Index arg2 ;
10365   bool result;
10366
10367   arg1 = (Dali::Property::Key *)jarg1;
10368   arg2 = (Dali::Property::Index)jarg2;
10369   {
10370     try {
10371       result = (bool)(arg1)->operator ==(arg2);
10372     } CALL_CATCH_EXCEPTION(0);
10373   }
10374
10375   jresult = result;
10376   return jresult;
10377 }
10378
10379
10380 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_2(void * jarg1, void * jarg2) {
10381   unsigned int jresult ;
10382   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
10383   Dali::Property::Key *arg2 = 0 ;
10384   bool result;
10385
10386   arg1 = (Dali::Property::Key *)jarg1;
10387   arg2 = (Dali::Property::Key *)jarg2;
10388   if (!arg2) {
10389     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
10390     return 0;
10391   }
10392   {
10393     try {
10394       result = (bool)(arg1)->operator ==((Dali::Property::Key const &)*arg2);
10395     } CALL_CATCH_EXCEPTION(0);
10396   }
10397
10398   jresult = result;
10399   return jresult;
10400 }
10401
10402
10403 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_0(void * jarg1, char * jarg2) {
10404   unsigned int jresult ;
10405   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
10406   std::string *arg2 = 0 ;
10407   bool result;
10408
10409   arg1 = (Dali::Property::Key *)jarg1;
10410   if (!jarg2) {
10411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10412     return 0;
10413   }
10414   std::string arg2_str(jarg2);
10415   arg2 = &arg2_str;
10416   {
10417     try {
10418       result = (bool)(arg1)->operator !=((std::string const &)*arg2);
10419     } CALL_CATCH_EXCEPTION(0);
10420   }
10421
10422   jresult = result;
10423
10424   //argout typemap for const std::string&
10425
10426   return jresult;
10427 }
10428
10429
10430 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_1(void * jarg1, int jarg2) {
10431   unsigned int jresult ;
10432   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
10433   Dali::Property::Index arg2 ;
10434   bool result;
10435
10436   arg1 = (Dali::Property::Key *)jarg1;
10437   arg2 = (Dali::Property::Index)jarg2;
10438   {
10439     try {
10440       result = (bool)(arg1)->operator !=(arg2);
10441     } CALL_CATCH_EXCEPTION(0);
10442   }
10443
10444   jresult = result;
10445   return jresult;
10446 }
10447
10448
10449 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_2(void * jarg1, void * jarg2) {
10450   unsigned int jresult ;
10451   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
10452   Dali::Property::Key *arg2 = 0 ;
10453   bool result;
10454
10455   arg1 = (Dali::Property::Key *)jarg1;
10456   arg2 = (Dali::Property::Key *)jarg2;
10457   if (!arg2) {
10458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
10459     return 0;
10460   }
10461   {
10462     try {
10463       result = (bool)(arg1)->operator !=((Dali::Property::Key const &)*arg2);
10464     } CALL_CATCH_EXCEPTION(0);
10465   }
10466
10467   jresult = result;
10468   return jresult;
10469 }
10470
10471
10472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Key(void * jarg1) {
10473   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
10474
10475   arg1 = (Dali::Property::Key *)jarg1;
10476   {
10477     try {
10478       delete arg1;
10479     } CALL_CATCH_EXCEPTION();
10480   }
10481
10482 }
10483
10484
10485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_0() {
10486   void * jresult ;
10487   Dali::Property::Map *result = 0 ;
10488
10489   {
10490     try {
10491       result = (Dali::Property::Map *)new Dali::Property::Map();
10492     } CALL_CATCH_EXCEPTION(0);
10493   }
10494
10495   jresult = (void *)result;
10496   return jresult;
10497 }
10498
10499
10500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_1(void * jarg1) {
10501   void * jresult ;
10502   Dali::Property::Map *arg1 = 0 ;
10503   Dali::Property::Map *result = 0 ;
10504
10505   arg1 = (Dali::Property::Map *)jarg1;
10506   if (!arg1) {
10507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
10508     return 0;
10509   }
10510   {
10511     try {
10512       result = (Dali::Property::Map *)new Dali::Property::Map((Dali::Property::Map const &)*arg1);
10513     } CALL_CATCH_EXCEPTION(0);
10514   }
10515
10516   jresult = (void *)result;
10517   return jresult;
10518 }
10519
10520
10521 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Map(void * jarg1) {
10522   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10523
10524   arg1 = (Dali::Property::Map *)jarg1;
10525   {
10526     try {
10527       delete arg1;
10528     } CALL_CATCH_EXCEPTION();
10529   }
10530
10531 }
10532
10533
10534 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Map_Count(void * jarg1) {
10535   unsigned long jresult ;
10536   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10537   Dali::Property::Map::SizeType result;
10538
10539   arg1 = (Dali::Property::Map *)jarg1;
10540   {
10541     try {
10542       result = ((Dali::Property::Map const *)arg1)->Count();
10543     } CALL_CATCH_EXCEPTION(0);
10544   }
10545
10546   jresult = (unsigned long)result;
10547   return jresult;
10548 }
10549
10550
10551 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Map_Empty(void * jarg1) {
10552   unsigned int jresult ;
10553   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10554   bool result;
10555
10556   arg1 = (Dali::Property::Map *)jarg1;
10557   {
10558     try {
10559       result = (bool)((Dali::Property::Map const *)arg1)->Empty();
10560     } CALL_CATCH_EXCEPTION(0);
10561   }
10562
10563   jresult = result;
10564   return jresult;
10565 }
10566
10567
10568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
10569   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10570   char *arg2 = (char *) 0 ;
10571   Dali::Property::Value *arg3 = 0 ;
10572
10573   arg1 = (Dali::Property::Map *)jarg1;
10574   arg2 = (char *)jarg2;
10575   arg3 = (Dali::Property::Value *)jarg3;
10576   if (!arg3) {
10577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
10578     return ;
10579   }
10580   {
10581     try {
10582       (arg1)->Insert((char const *)arg2,(Dali::Property::Value const &)*arg3);
10583     } CALL_CATCH_EXCEPTION();
10584   }
10585
10586 }
10587
10588
10589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
10590   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10591   Dali::Property::Index arg2 ;
10592   Dali::Property::Value *arg3 = 0 ;
10593
10594   arg1 = (Dali::Property::Map *)jarg1;
10595   arg2 = (Dali::Property::Index)jarg2;
10596   arg3 = (Dali::Property::Value *)jarg3;
10597   if (!arg3) {
10598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
10599     return ;
10600   }
10601   {
10602     try {
10603       (arg1)->Insert(arg2,(Dali::Property::Value const &)*arg3);
10604     } CALL_CATCH_EXCEPTION();
10605   }
10606
10607 }
10608
10609
10610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
10611   void * jresult ;
10612   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10613   char *arg2 = (char *) 0 ;
10614   Dali::Property::Value *arg3 = 0 ;
10615   Dali::Property::Map *result = 0 ;
10616
10617   arg1 = (Dali::Property::Map *)jarg1;
10618   arg2 = (char *)jarg2;
10619   arg3 = (Dali::Property::Value *)jarg3;
10620   if (!arg3) {
10621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
10622     return 0;
10623   }
10624   {
10625     try {
10626       result = (Dali::Property::Map *) &(arg1)->Add((char const *)arg2,(Dali::Property::Value const &)*arg3);
10627     } CALL_CATCH_EXCEPTION(0);
10628   }
10629
10630   jresult = (void *)result;
10631   return jresult;
10632 }
10633
10634
10635 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
10636   void * jresult ;
10637   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10638   Dali::Property::Index arg2 ;
10639   Dali::Property::Value *arg3 = 0 ;
10640   Dali::Property::Map *result = 0 ;
10641
10642   arg1 = (Dali::Property::Map *)jarg1;
10643   arg2 = (Dali::Property::Index)jarg2;
10644   arg3 = (Dali::Property::Value *)jarg3;
10645   if (!arg3) {
10646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
10647     return 0;
10648   }
10649   {
10650     try {
10651       result = (Dali::Property::Map *) &(arg1)->Add(arg2,(Dali::Property::Value const &)*arg3);
10652     } CALL_CATCH_EXCEPTION(0);
10653   }
10654
10655   jresult = (void *)result;
10656   return jresult;
10657 }
10658
10659
10660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetValue(void * jarg1, unsigned long jarg2) {
10661   void * jresult ;
10662   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10663   Dali::Property::Map::SizeType arg2 ;
10664   Dali::Property::Value *result = 0 ;
10665
10666   arg1 = (Dali::Property::Map *)jarg1;
10667   arg2 = (Dali::Property::Map::SizeType)jarg2;
10668   {
10669     try {
10670       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->GetValue(arg2);
10671     } CALL_CATCH_EXCEPTION(0);
10672   }
10673
10674   jresult = (void *)result;
10675   return jresult;
10676 }
10677
10678
10679 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Map_GetKey(void * jarg1, unsigned long jarg2) {
10680   char * jresult ;
10681   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10682   Dali::Property::Map::SizeType arg2 ;
10683   std::string *result = 0 ;
10684
10685   arg1 = (Dali::Property::Map *)jarg1;
10686   arg2 = (Dali::Property::Map::SizeType)jarg2;
10687   {
10688     try {
10689       result = (std::string *) &((Dali::Property::Map const *)arg1)->GetKey(arg2);
10690     } CALL_CATCH_EXCEPTION(0);
10691   }
10692
10693   jresult = SWIG_csharp_string_callback(result->c_str());
10694   return jresult;
10695 }
10696
10697
10698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetKeyAt(void * jarg1, unsigned long jarg2) {
10699   void * jresult ;
10700   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10701   Dali::Property::Map::SizeType arg2 ;
10702   SwigValueWrapper< Dali::Property::Key > result;
10703
10704   arg1 = (Dali::Property::Map *)jarg1;
10705   arg2 = (Dali::Property::Map::SizeType)jarg2;
10706   {
10707     try {
10708       result = ((Dali::Property::Map const *)arg1)->GetKeyAt(arg2);
10709     } CALL_CATCH_EXCEPTION(0);
10710   }
10711
10712   jresult = new Dali::Property::Key((const Dali::Property::Key &)result);
10713   return jresult;
10714 }
10715
10716
10717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetPair(void * jarg1, unsigned long jarg2) {
10718   void * jresult ;
10719   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10720   Dali::Property::Map::SizeType arg2 ;
10721   StringValuePair *result = 0 ;
10722
10723   arg1 = (Dali::Property::Map *)jarg1;
10724   arg2 = (Dali::Property::Map::SizeType)jarg2;
10725   {
10726     try {
10727       result = (StringValuePair *) &((Dali::Property::Map const *)arg1)->GetPair(arg2);
10728     } CALL_CATCH_EXCEPTION(0);
10729   }
10730
10731   jresult = (void *)result;
10732   return jresult;
10733 }
10734
10735
10736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_0(void * jarg1, char * jarg2) {
10737   void * jresult ;
10738   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10739   char *arg2 = (char *) 0 ;
10740   Dali::Property::Value *result = 0 ;
10741
10742   arg1 = (Dali::Property::Map *)jarg1;
10743   arg2 = (char *)jarg2;
10744   {
10745     try {
10746       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((char const *)arg2);
10747     } CALL_CATCH_EXCEPTION(0);
10748   }
10749
10750   jresult = (void *)result;
10751   return jresult;
10752 }
10753
10754
10755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_2(void * jarg1, int jarg2) {
10756   void * jresult ;
10757   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10758   Dali::Property::Index arg2 ;
10759   Dali::Property::Value *result = 0 ;
10760
10761   arg1 = (Dali::Property::Map *)jarg1;
10762   arg2 = (Dali::Property::Index)jarg2;
10763   {
10764     try {
10765       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2);
10766     } CALL_CATCH_EXCEPTION(0);
10767   }
10768
10769   jresult = (void *)result;
10770   return jresult;
10771 }
10772
10773
10774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_3(void * jarg1, int jarg2, char * jarg3) {
10775   void * jresult ;
10776   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10777   Dali::Property::Index arg2 ;
10778   std::string *arg3 = 0 ;
10779   Dali::Property::Value *result = 0 ;
10780
10781   arg1 = (Dali::Property::Map *)jarg1;
10782   arg2 = (Dali::Property::Index)jarg2;
10783   if (!jarg3) {
10784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10785     return 0;
10786   }
10787   std::string arg3_str(jarg3);
10788   arg3 = &arg3_str;
10789   {
10790     try {
10791       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,(std::string const &)*arg3);
10792     } CALL_CATCH_EXCEPTION(0);
10793   }
10794
10795   jresult = (void *)result;
10796
10797   //argout typemap for const std::string&
10798
10799   return jresult;
10800 }
10801
10802
10803 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_4(void * jarg1, char * jarg2, int jarg3) {
10804   void * jresult ;
10805   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10806   std::string *arg2 = 0 ;
10807   Dali::Property::Type arg3 ;
10808   Dali::Property::Value *result = 0 ;
10809
10810   arg1 = (Dali::Property::Map *)jarg1;
10811   if (!jarg2) {
10812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10813     return 0;
10814   }
10815   std::string arg2_str(jarg2);
10816   arg2 = &arg2_str;
10817   arg3 = (Dali::Property::Type)jarg3;
10818   {
10819     try {
10820       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((std::string const &)*arg2,arg3);
10821     } CALL_CATCH_EXCEPTION(0);
10822   }
10823
10824   jresult = (void *)result;
10825
10826   //argout typemap for const std::string&
10827
10828   return jresult;
10829 }
10830
10831
10832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_5(void * jarg1, int jarg2, int jarg3) {
10833   void * jresult ;
10834   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10835   Dali::Property::Index arg2 ;
10836   Dali::Property::Type arg3 ;
10837   Dali::Property::Value *result = 0 ;
10838
10839   arg1 = (Dali::Property::Map *)jarg1;
10840   arg2 = (Dali::Property::Index)jarg2;
10841   arg3 = (Dali::Property::Type)jarg3;
10842   {
10843     try {
10844       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,arg3);
10845     } CALL_CATCH_EXCEPTION(0);
10846   }
10847
10848   jresult = (void *)result;
10849   return jresult;
10850 }
10851
10852
10853 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Clear(void * jarg1) {
10854   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10855
10856   arg1 = (Dali::Property::Map *)jarg1;
10857   {
10858     try {
10859       (arg1)->Clear();
10860     } CALL_CATCH_EXCEPTION();
10861   }
10862
10863 }
10864
10865
10866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Merge(void * jarg1, void * jarg2) {
10867   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10868   Dali::Property::Map *arg2 = 0 ;
10869
10870   arg1 = (Dali::Property::Map *)jarg1;
10871   arg2 = (Dali::Property::Map *)jarg2;
10872   if (!arg2) {
10873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
10874     return ;
10875   }
10876   {
10877     try {
10878       (arg1)->Merge((Dali::Property::Map const &)*arg2);
10879     } CALL_CATCH_EXCEPTION();
10880   }
10881
10882 }
10883
10884
10885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_0(void * jarg1, char * jarg2) {
10886   void * jresult ;
10887   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10888   std::string *arg2 = 0 ;
10889   Dali::Property::Value *result = 0 ;
10890
10891   arg1 = (Dali::Property::Map *)jarg1;
10892   if (!jarg2) {
10893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10894     return 0;
10895   }
10896   std::string arg2_str(jarg2);
10897   arg2 = &arg2_str;
10898   {
10899     try {
10900       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator []((std::string const &)*arg2);
10901     } CALL_CATCH_EXCEPTION(0);
10902   }
10903
10904   jresult = (void *)result;
10905
10906   //argout typemap for const std::string&
10907
10908   return jresult;
10909 }
10910
10911
10912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_2(void * jarg1, int jarg2) {
10913   void * jresult ;
10914   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10915   Dali::Property::Index arg2 ;
10916   Dali::Property::Value *result = 0 ;
10917
10918   arg1 = (Dali::Property::Map *)jarg1;
10919   arg2 = (Dali::Property::Index)jarg2;
10920   {
10921     try {
10922       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator [](arg2);
10923     } CALL_CATCH_EXCEPTION(0);
10924   }
10925
10926   jresult = (void *)result;
10927   return jresult;
10928 }
10929
10930
10931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Assign(void * jarg1, void * jarg2) {
10932   void * jresult ;
10933   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
10934   Dali::Property::Map *arg2 = 0 ;
10935   Dali::Property::Map *result = 0 ;
10936
10937   arg1 = (Dali::Property::Map *)jarg1;
10938   arg2 = (Dali::Property::Map *)jarg2;
10939   if (!arg2) {
10940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
10941     return 0;
10942   }
10943   {
10944     try {
10945       result = (Dali::Property::Map *) &(arg1)->operator =((Dali::Property::Map const &)*arg2);
10946     } CALL_CATCH_EXCEPTION(0);
10947   }
10948
10949   jresult = (void *)result;
10950   return jresult;
10951 }
10952
10953
10954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_StringKey(void* jarg1, char* jarg2, void* jarg3) {
10955
10956   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
10957
10958   if (!jarg2) {
10959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10960     return;
10961   }
10962   std::string arg2_str(jarg2);
10963   std::string* arg2 = &arg2_str;
10964
10965   Dali::Property::Value* arg3 = (Dali::Property::Value*)jarg3;
10966
10967   {
10968     try {
10969       arg1->operator[]((std::string const &)*arg2) = *arg3;
10970     } CALL_CATCH_EXCEPTION();
10971   }
10972 }
10973
10974
10975 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_IntKey(void* jarg1, int jarg2, void* jarg3) {
10976
10977   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
10978   Dali::Property::Index arg2 = (Dali::Property::Index)jarg2;
10979   Dali::Property::Value* arg3 = (Dali::Property::Value*)jarg3;
10980
10981   {
10982     try {
10983       arg1->operator[](arg2) = *arg3;
10984     } CALL_CATCH_EXCEPTION();
10985   }
10986 }
10987
10988
10989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_0() {
10990   void * jresult ;
10991   Dali::Property::Value *result = 0 ;
10992
10993   {
10994     try {
10995       result = (Dali::Property::Value *)new Dali::Property::Value();
10996     } CALL_CATCH_EXCEPTION(0);
10997   }
10998
10999   jresult = (void *)result;
11000   return jresult;
11001 }
11002
11003
11004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_1(unsigned int jarg1) {
11005   void * jresult ;
11006   bool arg1 ;
11007   Dali::Property::Value *result = 0 ;
11008
11009   arg1 = jarg1 ? true : false;
11010   {
11011     try {
11012       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
11013     } CALL_CATCH_EXCEPTION(0);
11014   }
11015
11016   jresult = (void *)result;
11017   return jresult;
11018 }
11019
11020
11021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_2(int jarg1) {
11022   void * jresult ;
11023   int arg1 ;
11024   Dali::Property::Value *result = 0 ;
11025
11026   arg1 = (int)jarg1;
11027   {
11028     try {
11029       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
11030     } CALL_CATCH_EXCEPTION(0);
11031   }
11032
11033   jresult = (void *)result;
11034   return jresult;
11035 }
11036
11037
11038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_3(float jarg1) {
11039   void * jresult ;
11040   float arg1 ;
11041   Dali::Property::Value *result = 0 ;
11042
11043   arg1 = (float)jarg1;
11044   {
11045     try {
11046       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
11047     } CALL_CATCH_EXCEPTION(0);
11048   }
11049
11050   jresult = (void *)result;
11051   return jresult;
11052 }
11053
11054
11055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_4(void * jarg1) {
11056   void * jresult ;
11057   Dali::Vector2 *arg1 = 0 ;
11058   Dali::Property::Value *result = 0 ;
11059
11060   arg1 = (Dali::Vector2 *)jarg1;
11061   if (!arg1) {
11062     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
11063     return 0;
11064   }
11065   {
11066     try {
11067       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector2 const &)*arg1);
11068     } CALL_CATCH_EXCEPTION(0);
11069   }
11070
11071   jresult = (void *)result;
11072   return jresult;
11073 }
11074
11075
11076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_5(void * jarg1) {
11077   void * jresult ;
11078   Dali::Vector3 *arg1 = 0 ;
11079   Dali::Property::Value *result = 0 ;
11080
11081   arg1 = (Dali::Vector3 *)jarg1;
11082   if (!arg1) {
11083     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11084     return 0;
11085   }
11086   {
11087     try {
11088       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector3 const &)*arg1);
11089     } CALL_CATCH_EXCEPTION(0);
11090   }
11091
11092   jresult = (void *)result;
11093   return jresult;
11094 }
11095
11096
11097 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_6(void * jarg1) {
11098   void * jresult ;
11099   Dali::Vector4 *arg1 = 0 ;
11100   Dali::Property::Value *result = 0 ;
11101
11102   arg1 = (Dali::Vector4 *)jarg1;
11103   if (!arg1) {
11104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
11105     return 0;
11106   }
11107   {
11108     try {
11109       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector4 const &)*arg1);
11110     } CALL_CATCH_EXCEPTION(0);
11111   }
11112
11113   jresult = (void *)result;
11114   return jresult;
11115 }
11116
11117
11118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_7(void * jarg1) {
11119   void * jresult ;
11120   Dali::Matrix3 *arg1 = 0 ;
11121   Dali::Property::Value *result = 0 ;
11122
11123   arg1 = (Dali::Matrix3 *)jarg1;
11124   if (!arg1) {
11125     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
11126     return 0;
11127   }
11128   {
11129     try {
11130       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix3 const &)*arg1);
11131     } CALL_CATCH_EXCEPTION(0);
11132   }
11133
11134   jresult = (void *)result;
11135   return jresult;
11136 }
11137
11138
11139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_8(void * jarg1) {
11140   void * jresult ;
11141   Dali::Matrix *arg1 = 0 ;
11142   Dali::Property::Value *result = 0 ;
11143
11144   arg1 = (Dali::Matrix *)jarg1;
11145   if (!arg1) {
11146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11147     return 0;
11148   }
11149   {
11150     try {
11151       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix const &)*arg1);
11152     } CALL_CATCH_EXCEPTION(0);
11153   }
11154
11155   jresult = (void *)result;
11156   return jresult;
11157 }
11158
11159
11160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_9(void * jarg1) {
11161   void * jresult ;
11162   Dali::Rect< int > *arg1 = 0 ;
11163   Dali::Property::Value *result = 0 ;
11164
11165   arg1 = (Dali::Rect< int > *)jarg1;
11166   if (!arg1) {
11167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
11168     return 0;
11169   }
11170   {
11171     try {
11172       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Rect< int > const &)*arg1);
11173     } CALL_CATCH_EXCEPTION(0);
11174   }
11175
11176   jresult = (void *)result;
11177   return jresult;
11178 }
11179
11180
11181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_10(void * jarg1) {
11182   void * jresult ;
11183   Dali::AngleAxis *arg1 = 0 ;
11184   Dali::Property::Value *result = 0 ;
11185
11186   arg1 = (Dali::AngleAxis *)jarg1;
11187   if (!arg1) {
11188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
11189     return 0;
11190   }
11191   {
11192     try {
11193       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::AngleAxis const &)*arg1);
11194     } CALL_CATCH_EXCEPTION(0);
11195   }
11196
11197   jresult = (void *)result;
11198   return jresult;
11199 }
11200
11201
11202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_11(void * jarg1) {
11203   void * jresult ;
11204   Dali::Quaternion *arg1 = 0 ;
11205   Dali::Property::Value *result = 0 ;
11206
11207   arg1 = (Dali::Quaternion *)jarg1;
11208   if (!arg1) {
11209     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11210     return 0;
11211   }
11212   {
11213     try {
11214       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Quaternion const &)*arg1);
11215     } CALL_CATCH_EXCEPTION(0);
11216   }
11217
11218   jresult = (void *)result;
11219   return jresult;
11220 }
11221
11222
11223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_12(char * jarg1) {
11224   void * jresult ;
11225   std::string *arg1 = 0 ;
11226   Dali::Property::Value *result = 0 ;
11227
11228   if (!jarg1) {
11229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
11230     return 0;
11231   }
11232   std::string arg1_str(jarg1);
11233   arg1 = &arg1_str;
11234   {
11235     try {
11236       result = (Dali::Property::Value *)new Dali::Property::Value((std::string const &)*arg1);
11237     } CALL_CATCH_EXCEPTION(0);
11238   }
11239
11240   jresult = (void *)result;
11241
11242   //argout typemap for const std::string&
11243
11244   return jresult;
11245 }
11246
11247
11248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_14(void * jarg1) {
11249   void * jresult ;
11250   Dali::Property::Array *arg1 = 0 ;
11251   Dali::Property::Value *result = 0 ;
11252
11253   arg1 = (Dali::Property::Array *)jarg1;
11254   if (!arg1) {
11255     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
11256     return 0;
11257   }
11258   {
11259     try {
11260       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
11261     } CALL_CATCH_EXCEPTION(0);
11262   }
11263
11264   jresult = (void *)result;
11265   return jresult;
11266 }
11267
11268
11269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_15(void * jarg1) {
11270   void * jresult ;
11271   Dali::Property::Map *arg1 = 0 ;
11272   Dali::Property::Value *result = 0 ;
11273
11274   arg1 = (Dali::Property::Map *)jarg1;
11275   if (!arg1) {
11276     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
11277     return 0;
11278   }
11279   {
11280     try {
11281       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
11282     } CALL_CATCH_EXCEPTION(0);
11283   }
11284
11285   jresult = (void *)result;
11286   return jresult;
11287 }
11288
11289
11290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_16(void * jarg1) {
11291   void * jresult ;
11292   Extents *arg1 = 0 ;
11293   Dali::Property::Value *result = 0 ;
11294
11295   arg1 = (Extents *)jarg1;
11296   if (!arg1) {
11297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents const & type is null", 0);
11298     return 0;
11299   }
11300   {
11301     try {
11302       result = (Dali::Property::Value *)new Dali::Property::Value((Extents const &)*arg1);
11303     } CALL_CATCH_EXCEPTION(0);
11304   }
11305
11306   jresult = (void*) result;
11307   return jresult;
11308 }
11309
11310
11311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_17(int jarg1) {
11312   void * jresult ;
11313   Dali::Property::Type arg1 ;
11314   Dali::Property::Value *result = 0 ;
11315
11316   arg1 = (Dali::Property::Type)jarg1;
11317   {
11318     try {
11319       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
11320     } CALL_CATCH_EXCEPTION(0);
11321   }
11322
11323   jresult = (void *)result;
11324   return jresult;
11325 }
11326
11327
11328 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_18(void * jarg1) {
11329   void * jresult ;
11330   Dali::Property::Value *arg1 = 0 ;
11331   Dali::Property::Value *result = 0 ;
11332
11333   arg1 = (Dali::Property::Value *)jarg1;
11334   if (!arg1) {
11335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
11336     return 0;
11337   }
11338   {
11339     try {
11340       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Property::Value const &)*arg1);
11341     } CALL_CATCH_EXCEPTION(0);
11342   }
11343
11344   jresult = (void *)result;
11345   return jresult;
11346 }
11347
11348
11349 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_Assign(void * jarg1, void * jarg2) {
11350   void * jresult ;
11351   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11352   Dali::Property::Value *arg2 = 0 ;
11353   Dali::Property::Value *result = 0 ;
11354
11355   arg1 = (Dali::Property::Value *)jarg1;
11356   arg2 = (Dali::Property::Value *)jarg2;
11357   if (!arg2) {
11358     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
11359     return 0;
11360   }
11361   {
11362     try {
11363       result = (Dali::Property::Value *) &(arg1)->operator =((Dali::Property::Value const &)*arg2);
11364     } CALL_CATCH_EXCEPTION(0);
11365   }
11366
11367   jresult = (void *)result;
11368   return jresult;
11369 }
11370
11371
11372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Value(void * jarg1) {
11373   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11374
11375   arg1 = (Dali::Property::Value *)jarg1;
11376   {
11377     try {
11378       delete arg1;
11379     } CALL_CATCH_EXCEPTION();
11380   }
11381
11382 }
11383
11384
11385 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Value_GetType(void * jarg1) {
11386   int jresult ;
11387   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11388   Dali::Property::Type result;
11389
11390   arg1 = (Dali::Property::Value *)jarg1;
11391   {
11392     try {
11393       result = (Dali::Property::Type)((Dali::Property::Value const *)arg1)->GetType();
11394     } CALL_CATCH_EXCEPTION(0);
11395   }
11396
11397   jresult = (int)result;
11398   return jresult;
11399 }
11400
11401
11402 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_1(void * jarg1, unsigned int * jarg2) {
11403   unsigned int jresult ;
11404   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11405   bool *arg2 = 0 ;
11406   bool result;
11407
11408   arg1 = (Dali::Property::Value *)jarg1;
11409   arg2 = (bool *)jarg2;
11410   {
11411     try {
11412       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11413     } CALL_CATCH_EXCEPTION(0);
11414   }
11415
11416   jresult = result;
11417   return jresult;
11418 }
11419
11420
11421 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_2(void * jarg1, float * jarg2) {
11422   unsigned int jresult ;
11423   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11424   float *arg2 = 0 ;
11425   bool result;
11426
11427   arg1 = (Dali::Property::Value *)jarg1;
11428   arg2 = (float *)jarg2;
11429   {
11430     try {
11431       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11432     } CALL_CATCH_EXCEPTION(0);
11433   }
11434
11435   jresult = result;
11436   return jresult;
11437 }
11438
11439
11440 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_3(void * jarg1, int * jarg2) {
11441   unsigned int jresult ;
11442   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11443   int *arg2 = 0 ;
11444   bool result;
11445
11446   arg1 = (Dali::Property::Value *)jarg1;
11447   arg2 = (int *)jarg2;
11448   {
11449     try {
11450       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11451     } CALL_CATCH_EXCEPTION(0);
11452   }
11453
11454   jresult = result;
11455   return jresult;
11456 }
11457
11458
11459 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_4(void * jarg1, void * jarg2) {
11460   unsigned int jresult ;
11461   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11462   Dali::Rect< int > *arg2 = 0 ;
11463   bool result;
11464
11465   arg1 = (Dali::Property::Value *)jarg1;
11466   arg2 = (Dali::Rect< int > *)jarg2;
11467   if (!arg2) {
11468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > & type is null", 0);
11469     return 0;
11470   }
11471   {
11472     try {
11473       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11474     } CALL_CATCH_EXCEPTION(0);
11475   }
11476
11477   jresult = result;
11478   return jresult;
11479 }
11480
11481
11482 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_5(void * jarg1, void * jarg2) {
11483   unsigned int jresult ;
11484   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11485   Dali::Vector2 *arg2 = 0 ;
11486   bool result;
11487
11488   arg1 = (Dali::Property::Value *)jarg1;
11489   arg2 = (Dali::Vector2 *)jarg2;
11490   if (!arg2) {
11491     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
11492     return 0;
11493   }
11494   {
11495     try {
11496       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11497     } CALL_CATCH_EXCEPTION(0);
11498   }
11499
11500   jresult = result;
11501   return jresult;
11502 }
11503
11504
11505 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_6(void * jarg1, void * jarg2) {
11506   unsigned int jresult ;
11507   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11508   Dali::Vector3 *arg2 = 0 ;
11509   bool result;
11510
11511   arg1 = (Dali::Property::Value *)jarg1;
11512   arg2 = (Dali::Vector3 *)jarg2;
11513   if (!arg2) {
11514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11515     return 0;
11516   }
11517   {
11518     try {
11519       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11520     } CALL_CATCH_EXCEPTION(0);
11521   }
11522
11523   jresult = result;
11524   return jresult;
11525 }
11526
11527
11528 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_7(void * jarg1, void * jarg2) {
11529   unsigned int jresult ;
11530   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11531   Dali::Vector4 *arg2 = 0 ;
11532   bool result;
11533
11534   arg1 = (Dali::Property::Value *)jarg1;
11535   arg2 = (Dali::Vector4 *)jarg2;
11536   if (!arg2) {
11537     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 & type is null", 0);
11538     return 0;
11539   }
11540   {
11541     try {
11542       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11543     } CALL_CATCH_EXCEPTION(0);
11544   }
11545
11546   jresult = result;
11547   return jresult;
11548 }
11549
11550
11551 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_8(void * jarg1, void * jarg2) {
11552   unsigned int jresult ;
11553   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11554   Dali::Matrix3 *arg2 = 0 ;
11555   bool result;
11556
11557   arg1 = (Dali::Property::Value *)jarg1;
11558   arg2 = (Dali::Matrix3 *)jarg2;
11559   if (!arg2) {
11560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
11561     return 0;
11562   }
11563   {
11564     try {
11565       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11566     } CALL_CATCH_EXCEPTION(0);
11567   }
11568
11569   jresult = result;
11570   return jresult;
11571 }
11572
11573
11574 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_9(void * jarg1, void * jarg2) {
11575   unsigned int jresult ;
11576   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11577   Dali::Matrix *arg2 = 0 ;
11578   bool result;
11579
11580   arg1 = (Dali::Property::Value *)jarg1;
11581   arg2 = (Dali::Matrix *)jarg2;
11582   if (!arg2) {
11583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
11584     return 0;
11585   }
11586   {
11587     try {
11588       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11589     } CALL_CATCH_EXCEPTION(0);
11590   }
11591
11592   jresult = result;
11593   return jresult;
11594 }
11595
11596
11597 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_10(void * jarg1, void * jarg2) {
11598   unsigned int jresult ;
11599   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11600   Dali::AngleAxis *arg2 = 0 ;
11601   bool result;
11602
11603   arg1 = (Dali::Property::Value *)jarg1;
11604   arg2 = (Dali::AngleAxis *)jarg2;
11605   if (!arg2) {
11606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis & type is null", 0);
11607     return 0;
11608   }
11609   {
11610     try {
11611       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11612     } CALL_CATCH_EXCEPTION(0);
11613   }
11614
11615   jresult = result;
11616   return jresult;
11617 }
11618
11619
11620 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_11(void * jarg1, void * jarg2) {
11621   unsigned int jresult ;
11622   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11623   Dali::Quaternion *arg2 = 0 ;
11624   bool result;
11625
11626   arg1 = (Dali::Property::Value *)jarg1;
11627   arg2 = (Dali::Quaternion *)jarg2;
11628   if (!arg2) {
11629     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
11630     return 0;
11631   }
11632   {
11633     try {
11634       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11635     } CALL_CATCH_EXCEPTION(0);
11636   }
11637
11638   jresult = result;
11639   return jresult;
11640 }
11641
11642
11643 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_12(void * jarg1, char** jarg2) {
11644   unsigned int jresult ;
11645   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11646   std::string *arg2 = 0 ;
11647   bool result;
11648
11649   arg1 = (Dali::Property::Value *)jarg1;
11650
11651   //typemap in
11652   std::string temp;
11653   arg2 = &temp;
11654
11655   {
11656     try {
11657       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11658     } CALL_CATCH_EXCEPTION(0);
11659   }
11660
11661   jresult = result;
11662
11663   //Typemap argout in c++ file.
11664   //This will convert c++ string to c# string
11665   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
11666
11667   return jresult;
11668 }
11669
11670
11671 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_13(void * jarg1, void * jarg2) {
11672   unsigned int jresult ;
11673   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11674   Dali::Property::Array *arg2 = 0 ;
11675   bool result;
11676
11677   arg1 = (Dali::Property::Value *)jarg1;
11678   arg2 = (Dali::Property::Array *)jarg2;
11679   if (!arg2) {
11680     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
11681     return 0;
11682   }
11683   {
11684     try {
11685       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11686     } CALL_CATCH_EXCEPTION(0);
11687   }
11688
11689   jresult = result;
11690   return jresult;
11691 }
11692
11693
11694 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_14(void * jarg1, void * jarg2) {
11695   unsigned int jresult ;
11696   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11697   Dali::Property::Map *arg2 = 0 ;
11698   bool result;
11699
11700   arg1 = (Dali::Property::Value *)jarg1;
11701   arg2 = (Dali::Property::Map *)jarg2;
11702   if (!arg2) {
11703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
11704     return 0;
11705   }
11706   {
11707     try {
11708       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11709     } CALL_CATCH_EXCEPTION(0);
11710   }
11711
11712   jresult = result;
11713   return jresult;
11714 }
11715
11716
11717 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_15(void * jarg1, void * jarg2) {
11718   unsigned int jresult ;
11719   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11720   Extents *arg2 = 0 ;
11721   bool result;
11722
11723   arg1 = (Dali::Property::Value *)jarg1;
11724   arg2 = (Extents *)jarg2;
11725   if (!arg2) {
11726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents & type is null", 0);
11727     return 0;
11728   }
11729   {
11730     try {
11731       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
11732     } CALL_CATCH_EXCEPTION(0);
11733   }
11734   jresult = result;
11735   return jresult;
11736 }
11737
11738 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetArray(void * jarg1) {
11739   void * jresult ;
11740   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11741   Dali::Property::Array *result = 0 ;
11742
11743   arg1 = (Dali::Property::Value *)jarg1;
11744   {
11745     try {
11746       result = (Dali::Property::Array *)((Dali::Property::Value const *)arg1)->GetArray();
11747     } CALL_CATCH_EXCEPTION(0);
11748   }
11749
11750   jresult = (void *)result;
11751   return jresult;
11752 }
11753
11754
11755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetMap(void * jarg1) {
11756   void * jresult ;
11757   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
11758   Dali::Property::Map *result = 0 ;
11759
11760   arg1 = (Dali::Property::Value *)jarg1;
11761   {
11762     try {
11763       result = (Dali::Property::Map *)((Dali::Property::Value const *)arg1)->GetMap();
11764     } CALL_CATCH_EXCEPTION(0);
11765   }
11766
11767   jresult = (void *)result;
11768   return jresult;
11769 }
11770
11771
11772 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetName(int jarg1) {
11773   char * jresult ;
11774   Dali::Property::Type arg1 ;
11775   char *result = 0 ;
11776
11777   arg1 = (Dali::Property::Type)jarg1;
11778   {
11779     try {
11780       result = (char *)Dali::PropertyTypes::GetName(arg1);
11781     } CALL_CATCH_EXCEPTION(0);
11782   }
11783
11784   jresult = SWIG_csharp_string_callback((const char *)result);
11785   return jresult;
11786 }
11787
11788
11789 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoAction(void * jarg1, char * jarg2, void * jarg3) {
11790   unsigned int jresult ;
11791   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
11792   std::string *arg2 = 0 ;
11793   Dali::Property::Map *arg3 = 0 ;
11794   bool result;
11795
11796   arg1 = (Dali::BaseObject *)jarg1;
11797   if (!jarg2) {
11798     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
11799     return 0;
11800   }
11801   std::string arg2_str(jarg2);
11802   arg2 = &arg2_str;
11803   arg3 = (Dali::Property::Map *)jarg3;
11804   if (!arg3) {
11805     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
11806     return 0;
11807   }
11808   {
11809     try {
11810       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
11811     } CALL_CATCH_EXCEPTION(0);
11812   }
11813
11814   jresult = result;
11815
11816   //argout typemap for const std::string&
11817
11818   return jresult;
11819 }
11820
11821
11822 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeName(void * jarg1) {
11823   char * jresult ;
11824   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
11825   std::string *result = 0 ;
11826
11827   arg1 = (Dali::BaseObject *)jarg1;
11828   {
11829     try {
11830       result = (std::string *) &((Dali::BaseObject const *)arg1)->GetTypeName();
11831     } CALL_CATCH_EXCEPTION(0);
11832   }
11833
11834   jresult = SWIG_csharp_string_callback(result->c_str());
11835   return jresult;
11836 }
11837
11838
11839 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeInfo(void * jarg1, void * jarg2) {
11840   unsigned int jresult ;
11841   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
11842   Dali::TypeInfo *arg2 = 0 ;
11843   bool result;
11844
11845   arg1 = (Dali::BaseObject *)jarg1;
11846   arg2 = (Dali::TypeInfo *)jarg2;
11847   if (!arg2) {
11848     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
11849     return 0;
11850   }
11851   {
11852     try {
11853       result = (bool)((Dali::BaseObject const *)arg1)->GetTypeInfo(*arg2);
11854     } CALL_CATCH_EXCEPTION(0);
11855   }
11856
11857   jresult = result;
11858   return jresult;
11859 }
11860
11861
11862 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoConnectSignal(void * jarg1, void * jarg2, char * jarg3, void * jarg4) {
11863   unsigned int jresult ;
11864   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
11865   ConnectionTrackerInterface *arg2 = (ConnectionTrackerInterface *) 0 ;
11866   std::string *arg3 = 0 ;
11867   FunctorDelegate *arg4 = (FunctorDelegate *) 0 ;
11868   bool result;
11869
11870   arg1 = (Dali::BaseObject *)jarg1;
11871   arg2 = (ConnectionTrackerInterface *)jarg2;
11872   if (!jarg3) {
11873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
11874     return 0;
11875   }
11876   std::string arg3_str(jarg3);
11877   arg3 = &arg3_str;
11878   arg4 = (FunctorDelegate *)jarg4;
11879   {
11880     try {
11881       result = (bool)(arg1)->DoConnectSignal(arg2,(std::string const &)*arg3,arg4);
11882     } CALL_CATCH_EXCEPTION(0);
11883   }
11884
11885   jresult = result;
11886
11887   //argout typemap for const std::string&
11888
11889   return jresult;
11890 }
11891
11892
11893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation(void * jarg1) {
11894   void * jresult ;
11895   Dali::BaseHandle *arg1 = 0 ;
11896   Dali::BaseObject *result = 0 ;
11897
11898   arg1 = (Dali::BaseHandle *)jarg1;
11899   if (!arg1) {
11900     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
11901     return 0;
11902   }
11903   {
11904     try {
11905       result = (Dali::BaseObject *) &Dali::GetImplementation((Dali::BaseHandle const &)*arg1);
11906     } CALL_CATCH_EXCEPTION(0);
11907   }
11908
11909   jresult = (void *)result;
11910   return jresult;
11911 }
11912
11913
11914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_0(void * jarg1) {
11915   void * jresult ;
11916   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
11917   Dali::BaseHandle *result = 0 ;
11918
11919   arg1 = (Dali::BaseObject *)jarg1;
11920   {
11921     try {
11922       result = (Dali::BaseHandle *)new Dali::BaseHandle(arg1);
11923     } CALL_CATCH_EXCEPTION(0);
11924   }
11925
11926   jresult = (void *)result;
11927   return jresult;
11928 }
11929
11930
11931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_1() {
11932   void * jresult ;
11933   Dali::BaseHandle *result = 0 ;
11934
11935   {
11936     try {
11937       result = (Dali::BaseHandle *)new Dali::BaseHandle();
11938     } CALL_CATCH_EXCEPTION(0);
11939   }
11940
11941   jresult = (void *)result;
11942   return jresult;
11943 }
11944
11945
11946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BaseHandle(void * jarg1) {
11947   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
11948
11949   arg1 = (Dali::BaseHandle *)jarg1;
11950   {
11951     try {
11952       delete arg1;
11953     } CALL_CATCH_EXCEPTION();
11954   }
11955
11956 }
11957
11958
11959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_2(void * jarg1) {
11960   void * jresult ;
11961   Dali::BaseHandle *arg1 = 0 ;
11962   Dali::BaseHandle *result = 0 ;
11963
11964   arg1 = (Dali::BaseHandle *)jarg1;
11965   if (!arg1) {
11966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
11967     return 0;
11968   }
11969   {
11970     try {
11971       result = (Dali::BaseHandle *)new Dali::BaseHandle((Dali::BaseHandle const &)*arg1);
11972     } CALL_CATCH_EXCEPTION(0);
11973   }
11974
11975   jresult = (void *)result;
11976   return jresult;
11977 }
11978
11979
11980 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_Assign(void * jarg1, void * jarg2) {
11981   void * jresult ;
11982   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
11983   Dali::BaseHandle *arg2 = 0 ;
11984   Dali::BaseHandle *result = 0 ;
11985
11986   arg1 = (Dali::BaseHandle *)jarg1;
11987   arg2 = (Dali::BaseHandle *)jarg2;
11988   if (!arg2) {
11989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
11990     return 0;
11991   }
11992   {
11993     try {
11994       result = (Dali::BaseHandle *) &(arg1)->operator =((Dali::BaseHandle const &)*arg2);
11995     } CALL_CATCH_EXCEPTION(0);
11996   }
11997
11998   jresult = (void *)result;
11999   return jresult;
12000 }
12001
12002
12003 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_DoAction(void * jarg1, char * jarg2, void * jarg3) {
12004   unsigned int jresult ;
12005   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
12006   std::string *arg2 = 0 ;
12007   Dali::Property::Map *arg3 = 0 ;
12008   bool result;
12009
12010   arg1 = (Dali::BaseHandle *)jarg1;
12011   if (!jarg2) {
12012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
12013     return 0;
12014   }
12015   std::string arg2_str(jarg2);
12016   arg2 = &arg2_str;
12017   arg3 = (Dali::Property::Map *)jarg3;
12018   if (!arg3) {
12019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
12020     return 0;
12021   }
12022   {
12023     try {
12024       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
12025     } CALL_CATCH_EXCEPTION(0);
12026   }
12027
12028   jresult = result;
12029
12030   //argout typemap for const std::string&
12031
12032   return jresult;
12033 }
12034
12035
12036 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeName(void * jarg1) {
12037   char * jresult ;
12038   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
12039   std::string *result = 0 ;
12040
12041   arg1 = (Dali::BaseHandle *)jarg1;
12042   {
12043     try {
12044       result = (std::string *) &((Dali::BaseHandle const *)arg1)->GetTypeName();
12045     } CALL_CATCH_EXCEPTION(0);
12046   }
12047
12048   jresult = SWIG_csharp_string_callback(result->c_str());
12049   return jresult;
12050 }
12051
12052
12053 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeInfo(void * jarg1, void * jarg2) {
12054   unsigned int jresult ;
12055   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
12056   Dali::TypeInfo *arg2 = 0 ;
12057   bool result;
12058
12059   arg1 = (Dali::BaseHandle *)jarg1;
12060   arg2 = (Dali::TypeInfo *)jarg2;
12061   if (!arg2) {
12062     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
12063     return 0;
12064   }
12065   {
12066     try {
12067       result = (bool)((Dali::BaseHandle const *)arg1)->GetTypeInfo(*arg2);
12068     } CALL_CATCH_EXCEPTION(0);
12069   }
12070
12071   jresult = result;
12072   return jresult;
12073 }
12074
12075
12076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetBaseObject__SWIG_0(void * jarg1) {
12077   void * jresult ;
12078   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
12079   Dali::BaseObject *result = 0 ;
12080
12081   arg1 = (Dali::BaseHandle *)jarg1;
12082   {
12083     try {
12084       result = (Dali::BaseObject *) &(arg1)->GetBaseObject();
12085     } CALL_CATCH_EXCEPTION(0);
12086   }
12087
12088   jresult = (void *)result;
12089   return jresult;
12090 }
12091
12092
12093 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BaseHandle_Reset(void * jarg1) {
12094   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
12095
12096   arg1 = (Dali::BaseHandle *)jarg1;
12097   {
12098     try {
12099       (arg1)->Reset();
12100     } CALL_CATCH_EXCEPTION();
12101   }
12102
12103 }
12104
12105
12106 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_EqualTo(void * jarg1, void * jarg2) {
12107   unsigned int jresult ;
12108   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
12109   Dali::BaseHandle *arg2 = 0 ;
12110   bool result;
12111
12112   arg1 = (Dali::BaseHandle *)jarg1;
12113   arg2 = (Dali::BaseHandle *)jarg2;
12114   if (!arg2) {
12115     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
12116     return 0;
12117   }
12118   {
12119     try {
12120       result = (bool)((Dali::BaseHandle const *)arg1)->operator ==((Dali::BaseHandle const &)*arg2);
12121     } CALL_CATCH_EXCEPTION(0);
12122   }
12123
12124   jresult = result;
12125   return jresult;
12126 }
12127
12128
12129 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_NotEqualTo(void * jarg1, void * jarg2) {
12130   unsigned int jresult ;
12131   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
12132   Dali::BaseHandle *arg2 = 0 ;
12133   bool result;
12134
12135   arg1 = (Dali::BaseHandle *)jarg1;
12136   arg2 = (Dali::BaseHandle *)jarg2;
12137   if (!arg2) {
12138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
12139     return 0;
12140   }
12141   {
12142     try {
12143       result = (bool)((Dali::BaseHandle const *)arg1)->operator !=((Dali::BaseHandle const &)*arg2);
12144     } CALL_CATCH_EXCEPTION(0);
12145   }
12146
12147   jresult = result;
12148   return jresult;
12149 }
12150
12151
12152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetObjectPtr(void * jarg1) {
12153   void * jresult ;
12154   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
12155   Dali::RefObject *result = 0 ;
12156
12157   arg1 = (Dali::BaseHandle *)jarg1;
12158   {
12159     try {
12160       result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
12161     } CALL_CATCH_EXCEPTION(0);
12162   }
12163
12164   jresult = (void *)result;
12165   return jresult;
12166 }
12167
12168
12169 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_HasBody(void * jarg1) {
12170   unsigned int jresult ;
12171   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
12172   bool result;
12173
12174   arg1 = (Dali::BaseHandle *)jarg1;
12175   {
12176     try {
12177       result = (bool)Dali_BaseHandle_HasBody((Dali::BaseHandle const *)arg1);
12178     } CALL_CATCH_EXCEPTION(0);
12179   }
12180
12181   jresult = result;
12182   return jresult;
12183 }
12184
12185
12186 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_IsEqual(void * jarg1, void * jarg2) {
12187   unsigned int jresult ;
12188   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
12189   Dali::BaseHandle *arg2 = 0 ;
12190   bool result;
12191
12192   arg1 = (Dali::BaseHandle *)jarg1;
12193   arg2 = (Dali::BaseHandle *)jarg2;
12194   if (!arg2) {
12195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
12196     return 0;
12197   }
12198   {
12199     try {
12200       result = (bool)Dali_BaseHandle_IsEqual((Dali::BaseHandle const *)arg1,(Dali::BaseHandle const &)*arg2);
12201     } CALL_CATCH_EXCEPTION(0);
12202   }
12203
12204   jresult = result;
12205   return jresult;
12206 }
12207
12208
12209 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_3(void * jarg1, void * jarg2) {
12210   unsigned int jresult ;
12211   Dali::BaseHandle *arg1 = 0 ;
12212   Dali::BaseHandle *arg2 = 0 ;
12213   bool result;
12214
12215   arg1 = (Dali::BaseHandle *)jarg1;
12216   if (!arg1) {
12217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
12218     return 0;
12219   }
12220   arg2 = (Dali::BaseHandle *)jarg2;
12221   if (!arg2) {
12222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
12223     return 0;
12224   }
12225   {
12226     try {
12227       result = (bool)Dali::operator <((Dali::BaseHandle const &)*arg1,(Dali::BaseHandle const &)*arg2);
12228     } CALL_CATCH_EXCEPTION(0);
12229   }
12230
12231   jresult = result;
12232   return jresult;
12233 }
12234
12235
12236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTrackerInterface(void * jarg1) {
12237   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
12238
12239   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
12240   {
12241     try {
12242       delete arg1;
12243     } CALL_CATCH_EXCEPTION();
12244   }
12245
12246 }
12247
12248
12249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
12250   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
12251   SlotObserver *arg2 = (SlotObserver *) 0 ;
12252   CallbackBase *arg3 = (CallbackBase *) 0 ;
12253
12254   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
12255   arg2 = (SlotObserver *)jarg2;
12256   arg3 = (CallbackBase *)jarg3;
12257   {
12258     try {
12259       (arg1)->SignalConnected(arg2,arg3);
12260     } CALL_CATCH_EXCEPTION();
12261   }
12262
12263 }
12264
12265
12266 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalObserver(void * jarg1) {
12267   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
12268
12269   arg1 = (Dali::SignalObserver *)jarg1;
12270   {
12271     try {
12272       delete arg1;
12273     } CALL_CATCH_EXCEPTION();
12274   }
12275
12276 }
12277
12278
12279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SignalObserver_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
12280   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
12281   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
12282   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
12283
12284   arg1 = (Dali::SignalObserver *)jarg1;
12285   arg2 = (Dali::SlotObserver *)jarg2;
12286   arg3 = (Dali::CallbackBase *)jarg3;
12287   {
12288     try {
12289       (arg1)->SignalDisconnected(arg2,arg3);
12290     } CALL_CATCH_EXCEPTION();
12291   }
12292
12293 }
12294
12295
12296 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SlotObserver(void * jarg1) {
12297   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
12298
12299   arg1 = (Dali::SlotObserver *)jarg1;
12300   {
12301     try {
12302       delete arg1;
12303     } CALL_CATCH_EXCEPTION();
12304   }
12305
12306 }
12307
12308
12309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SlotObserver_SlotDisconnected(void * jarg1, void * jarg2) {
12310   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
12311   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
12312
12313   arg1 = (Dali::SlotObserver *)jarg1;
12314   arg2 = (Dali::CallbackBase *)jarg2;
12315   {
12316     try {
12317       (arg1)->SlotDisconnected(arg2);
12318     } CALL_CATCH_EXCEPTION();
12319   }
12320
12321 }
12322
12323
12324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTracker(void * jarg1) {
12325   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
12326
12327   arg1 = (Dali::ConnectionTracker *)jarg1;
12328   {
12329     try {
12330       delete arg1;
12331     } CALL_CATCH_EXCEPTION();
12332   }
12333
12334 }
12335
12336
12337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_DisconnectAll(void * jarg1) {
12338   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
12339
12340   arg1 = (Dali::ConnectionTracker *)jarg1;
12341   {
12342     try {
12343       (arg1)->DisconnectAll();
12344     } CALL_CATCH_EXCEPTION();
12345   }
12346
12347 }
12348
12349
12350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
12351   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
12352   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
12353   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
12354
12355   arg1 = (Dali::ConnectionTracker *)jarg1;
12356   arg2 = (Dali::SlotObserver *)jarg2;
12357   arg3 = (Dali::CallbackBase *)jarg3;
12358   {
12359     try {
12360       (arg1)->SignalConnected(arg2,arg3);
12361     } CALL_CATCH_EXCEPTION();
12362   }
12363
12364 }
12365
12366
12367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
12368   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
12369   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
12370   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
12371
12372   arg1 = (Dali::ConnectionTracker *)jarg1;
12373   arg2 = (Dali::SlotObserver *)jarg2;
12374   arg3 = (Dali::CallbackBase *)jarg3;
12375   {
12376     try {
12377       (arg1)->SignalDisconnected(arg2,arg3);
12378     } CALL_CATCH_EXCEPTION();
12379   }
12380
12381 }
12382
12383
12384 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ConnectionTracker_GetConnectionCount(void * jarg1) {
12385   unsigned long jresult ;
12386   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
12387   std::size_t result;
12388
12389   arg1 = (Dali::ConnectionTracker *)jarg1;
12390   {
12391     try {
12392       result = ((Dali::ConnectionTracker const *)arg1)->GetConnectionCount();
12393     } CALL_CATCH_EXCEPTION(0);
12394   }
12395
12396   jresult = (unsigned long)result;
12397   return jresult;
12398 }
12399
12400
12401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_0() {
12402   void * jresult ;
12403   Dali::ObjectRegistry *result = 0 ;
12404
12405   {
12406     try {
12407       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry();
12408     } CALL_CATCH_EXCEPTION(0);
12409   }
12410
12411   jresult = (void *)result;
12412   return jresult;
12413 }
12414
12415
12416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectRegistry(void * jarg1) {
12417   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
12418
12419   arg1 = (Dali::ObjectRegistry *)jarg1;
12420   {
12421     try {
12422       delete arg1;
12423     } CALL_CATCH_EXCEPTION();
12424   }
12425
12426 }
12427
12428
12429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_1(void * jarg1) {
12430   void * jresult ;
12431   Dali::ObjectRegistry *arg1 = 0 ;
12432   Dali::ObjectRegistry *result = 0 ;
12433
12434   arg1 = (Dali::ObjectRegistry *)jarg1;
12435   if (!arg1) {
12436     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
12437     return 0;
12438   }
12439   {
12440     try {
12441       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry((Dali::ObjectRegistry const &)*arg1);
12442     } CALL_CATCH_EXCEPTION(0);
12443   }
12444
12445   jresult = (void *)result;
12446   return jresult;
12447 }
12448
12449
12450 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_Assign(void * jarg1, void * jarg2) {
12451   void * jresult ;
12452   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
12453   Dali::ObjectRegistry *arg2 = 0 ;
12454   Dali::ObjectRegistry *result = 0 ;
12455
12456   arg1 = (Dali::ObjectRegistry *)jarg1;
12457   arg2 = (Dali::ObjectRegistry *)jarg2;
12458   if (!arg2) {
12459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
12460     return 0;
12461   }
12462   {
12463     try {
12464       result = (Dali::ObjectRegistry *) &(arg1)->operator =((Dali::ObjectRegistry const &)*arg2);
12465     } CALL_CATCH_EXCEPTION(0);
12466   }
12467
12468   jresult = (void *)result;
12469   return jresult;
12470 }
12471
12472
12473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectCreatedSignal(void * jarg1) {
12474   void * jresult ;
12475   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
12476   Dali::ObjectRegistry::ObjectCreatedSignalType *result = 0 ;
12477
12478   arg1 = (Dali::ObjectRegistry *)jarg1;
12479   {
12480     try {
12481       result = (Dali::ObjectRegistry::ObjectCreatedSignalType *) &(arg1)->ObjectCreatedSignal();
12482     } CALL_CATCH_EXCEPTION(0);
12483   }
12484
12485   jresult = (void *)result;
12486   return jresult;
12487 }
12488
12489
12490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectDestroyedSignal(void * jarg1) {
12491   void * jresult ;
12492   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
12493   Dali::ObjectRegistry::ObjectDestroyedSignalType *result = 0 ;
12494
12495   arg1 = (Dali::ObjectRegistry *)jarg1;
12496   {
12497     try {
12498       result = (Dali::ObjectRegistry::ObjectDestroyedSignalType *) &(arg1)->ObjectDestroyedSignal();
12499     } CALL_CATCH_EXCEPTION(0);
12500   }
12501
12502   jresult = (void *)result;
12503   return jresult;
12504 }
12505
12506
12507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_0() {
12508   void * jresult ;
12509   Dali::PropertyCondition *result = 0 ;
12510
12511   {
12512     try {
12513       result = (Dali::PropertyCondition *)new Dali::PropertyCondition();
12514     } CALL_CATCH_EXCEPTION(0);
12515   }
12516
12517   jresult = (void *)result;
12518   return jresult;
12519 }
12520
12521
12522 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyCondition(void * jarg1) {
12523   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
12524
12525   arg1 = (Dali::PropertyCondition *)jarg1;
12526   {
12527     try {
12528       delete arg1;
12529     } CALL_CATCH_EXCEPTION();
12530   }
12531
12532 }
12533
12534
12535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_1(void * jarg1) {
12536   void * jresult ;
12537   Dali::PropertyCondition *arg1 = 0 ;
12538   Dali::PropertyCondition *result = 0 ;
12539
12540   arg1 = (Dali::PropertyCondition *)jarg1;
12541   if (!arg1) {
12542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
12543     return 0;
12544   }
12545   {
12546     try {
12547       result = (Dali::PropertyCondition *)new Dali::PropertyCondition((Dali::PropertyCondition const &)*arg1);
12548     } CALL_CATCH_EXCEPTION(0);
12549   }
12550
12551   jresult = (void *)result;
12552   return jresult;
12553 }
12554
12555
12556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyCondition_Assign(void * jarg1, void * jarg2) {
12557   void * jresult ;
12558   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
12559   Dali::PropertyCondition *arg2 = 0 ;
12560   Dali::PropertyCondition *result = 0 ;
12561
12562   arg1 = (Dali::PropertyCondition *)jarg1;
12563   arg2 = (Dali::PropertyCondition *)jarg2;
12564   if (!arg2) {
12565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
12566     return 0;
12567   }
12568   {
12569     try {
12570       result = (Dali::PropertyCondition *) &(arg1)->operator =((Dali::PropertyCondition const &)*arg2);
12571     } CALL_CATCH_EXCEPTION(0);
12572   }
12573
12574   jresult = (void *)result;
12575   return jresult;
12576 }
12577
12578
12579 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgumentCount(void * jarg1) {
12580   unsigned long jresult ;
12581   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
12582   std::size_t result;
12583
12584   arg1 = (Dali::PropertyCondition *)jarg1;
12585   {
12586     try {
12587       result = ((Dali::PropertyCondition const *)arg1)->GetArgumentCount();
12588     } CALL_CATCH_EXCEPTION(0);
12589   }
12590   jresult = (unsigned long)result;
12591   return jresult;
12592 }
12593
12594
12595 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgument(void * jarg1, unsigned long jarg2) {
12596   float jresult ;
12597   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
12598   std::size_t arg2 ;
12599   float result;
12600
12601   arg1 = (Dali::PropertyCondition *)jarg1;
12602   arg2 = (std::size_t)jarg2;
12603   {
12604     try {
12605       result = (float)((Dali::PropertyCondition const *)arg1)->GetArgument(arg2);
12606     } CALL_CATCH_EXCEPTION(0);
12607   }
12608   jresult = result;
12609   return jresult;
12610 }
12611
12612
12613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LessThanCondition(float jarg1) {
12614   void * jresult ;
12615   float arg1 ;
12616   Dali::PropertyCondition result;
12617
12618   arg1 = (float)jarg1;
12619   {
12620     try {
12621       result = Dali::LessThanCondition(arg1);
12622     } CALL_CATCH_EXCEPTION(0);
12623   }
12624
12625   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
12626   return jresult;
12627 }
12628
12629
12630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GreaterThanCondition(float jarg1) {
12631   void * jresult ;
12632   float arg1 ;
12633   Dali::PropertyCondition result;
12634
12635   arg1 = (float)jarg1;
12636   {
12637     try {
12638       result = Dali::GreaterThanCondition(arg1);
12639     } CALL_CATCH_EXCEPTION(0);
12640   }
12641
12642   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
12643   return jresult;
12644 }
12645
12646
12647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InsideCondition(float jarg1, float jarg2) {
12648   void * jresult ;
12649   float arg1 ;
12650   float arg2 ;
12651   Dali::PropertyCondition result;
12652
12653   arg1 = (float)jarg1;
12654   arg2 = (float)jarg2;
12655   {
12656     try {
12657       result = Dali::InsideCondition(arg1,arg2);
12658     } CALL_CATCH_EXCEPTION(0);
12659   }
12660
12661   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
12662   return jresult;
12663 }
12664
12665
12666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OutsideCondition(float jarg1, float jarg2) {
12667   void * jresult ;
12668   float arg1 ;
12669   float arg2 ;
12670   Dali::PropertyCondition result;
12671
12672   arg1 = (float)jarg1;
12673   arg2 = (float)jarg2;
12674   {
12675     try {
12676       result = Dali::OutsideCondition(arg1,arg2);
12677     } CALL_CATCH_EXCEPTION(0);
12678   }
12679
12680   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
12681   return jresult;
12682 }
12683
12684
12685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_0(float jarg1, float jarg2) {
12686   void * jresult ;
12687   float arg1 ;
12688   float arg2 ;
12689   Dali::PropertyCondition result;
12690
12691   arg1 = (float)jarg1;
12692   arg2 = (float)jarg2;
12693   {
12694     try {
12695       result = Dali::StepCondition(arg1,arg2);
12696     } CALL_CATCH_EXCEPTION(0);
12697   }
12698
12699   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
12700   return jresult;
12701 }
12702
12703
12704 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_1(float jarg1) {
12705   void * jresult ;
12706   float arg1 ;
12707   Dali::PropertyCondition result;
12708
12709   arg1 = (float)jarg1;
12710   {
12711     try {
12712       result = Dali::StepCondition(arg1);
12713     } CALL_CATCH_EXCEPTION(0);
12714   }
12715
12716   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
12717   return jresult;
12718 }
12719
12720
12721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VariableStepCondition(void * jarg1) {
12722   void * jresult ;
12723   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg1 = 0 ;
12724   Dali::PropertyCondition result;
12725
12726   arg1 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg1;
12727   if (!arg1) {
12728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
12729     return 0;
12730   }
12731   {
12732     try {
12733       result = Dali::VariableStepCondition((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg1);
12734     } CALL_CATCH_EXCEPTION(0);
12735   }
12736
12737   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
12738   return jresult;
12739 }
12740
12741
12742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_0() {
12743   void * jresult ;
12744   Dali::PropertyNotification *result = 0 ;
12745
12746   {
12747     try {
12748       result = (Dali::PropertyNotification *)new Dali::PropertyNotification();
12749     } CALL_CATCH_EXCEPTION(0);
12750   }
12751
12752   jresult = (void *)result;
12753   return jresult;
12754 }
12755
12756
12757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_DownCast(void * jarg1) {
12758   void * jresult ;
12759   Dali::BaseHandle arg1 ;
12760   Dali::BaseHandle *argp1 ;
12761   Dali::PropertyNotification result;
12762
12763   argp1 = (Dali::BaseHandle *)jarg1;
12764   if (!argp1) {
12765     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
12766     return 0;
12767   }
12768   arg1 = *argp1;
12769   {
12770     try {
12771       result = Dali::PropertyNotification::DownCast(arg1);
12772     } CALL_CATCH_EXCEPTION(0);
12773   }
12774
12775   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
12776   return jresult;
12777 }
12778
12779
12780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotification(void * jarg1) {
12781   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
12782
12783   arg1 = (Dali::PropertyNotification *)jarg1;
12784   {
12785     try {
12786       delete arg1;
12787     } CALL_CATCH_EXCEPTION();
12788   }
12789
12790 }
12791
12792
12793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_1(void * jarg1) {
12794   void * jresult ;
12795   Dali::PropertyNotification *arg1 = 0 ;
12796   Dali::PropertyNotification *result = 0 ;
12797
12798   arg1 = (Dali::PropertyNotification *)jarg1;
12799   if (!arg1) {
12800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
12801     return 0;
12802   }
12803   {
12804     try {
12805       result = (Dali::PropertyNotification *)new Dali::PropertyNotification((Dali::PropertyNotification const &)*arg1);
12806     } CALL_CATCH_EXCEPTION(0);
12807   }
12808
12809   jresult = (void *)result;
12810   return jresult;
12811 }
12812
12813
12814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_Assign(void * jarg1, void * jarg2) {
12815   void * jresult ;
12816   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
12817   Dali::PropertyNotification *arg2 = 0 ;
12818   Dali::PropertyNotification *result = 0 ;
12819
12820   arg1 = (Dali::PropertyNotification *)jarg1;
12821   arg2 = (Dali::PropertyNotification *)jarg2;
12822   if (!arg2) {
12823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
12824     return 0;
12825   }
12826   {
12827     try {
12828       result = (Dali::PropertyNotification *) &(arg1)->operator =((Dali::PropertyNotification const &)*arg2);
12829     } CALL_CATCH_EXCEPTION(0);
12830   }
12831
12832   jresult = (void *)result;
12833   return jresult;
12834 }
12835
12836
12837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetCondition__SWIG_0(void * jarg1) {
12838   void * jresult ;
12839   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
12840   Dali::PropertyCondition result;
12841
12842   arg1 = (Dali::PropertyNotification *)jarg1;
12843   {
12844     try {
12845       result = (arg1)->GetCondition();
12846     } CALL_CATCH_EXCEPTION(0);
12847   }
12848
12849   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
12850   return jresult;
12851 }
12852
12853
12854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTarget(void * jarg1) {
12855   void * jresult ;
12856   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
12857   Dali::Handle result;
12858
12859   arg1 = (Dali::PropertyNotification *)jarg1;
12860   {
12861     try {
12862       result = ((Dali::PropertyNotification const *)arg1)->GetTarget();
12863     } CALL_CATCH_EXCEPTION(0);
12864   }
12865
12866   jresult = new Dali::Handle((const Dali::Handle &)result);
12867   return jresult;
12868 }
12869
12870
12871 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTargetProperty(void * jarg1) {
12872   int jresult ;
12873   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
12874   Dali::Property::Index result;
12875
12876   arg1 = (Dali::PropertyNotification *)jarg1;
12877   {
12878     try {
12879       result = (Dali::Property::Index)((Dali::PropertyNotification const *)arg1)->GetTargetProperty();
12880     } CALL_CATCH_EXCEPTION(0);
12881   }
12882
12883   jresult = result;
12884   return jresult;
12885 }
12886
12887
12888 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotification_SetNotifyMode(void * jarg1, int jarg2) {
12889   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
12890   Dali::PropertyNotification::NotifyMode arg2 ;
12891
12892   arg1 = (Dali::PropertyNotification *)jarg1;
12893   arg2 = (Dali::PropertyNotification::NotifyMode)jarg2;
12894   {
12895     try {
12896       (arg1)->SetNotifyMode(arg2);
12897     } CALL_CATCH_EXCEPTION();
12898   }
12899
12900 }
12901
12902
12903 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyMode(void * jarg1) {
12904   int jresult ;
12905   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
12906   Dali::PropertyNotification::NotifyMode result;
12907
12908   arg1 = (Dali::PropertyNotification *)jarg1;
12909   {
12910     try {
12911       result = (Dali::PropertyNotification::NotifyMode)(arg1)->GetNotifyMode();
12912     } CALL_CATCH_EXCEPTION(0);
12913   }
12914
12915   jresult = (int)result;
12916   return jresult;
12917 }
12918
12919
12920 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyResult(void * jarg1) {
12921   unsigned int jresult ;
12922   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
12923   bool result;
12924
12925   arg1 = (Dali::PropertyNotification *)jarg1;
12926   {
12927     try {
12928       result = (bool)((Dali::PropertyNotification const *)arg1)->GetNotifyResult();
12929     } CALL_CATCH_EXCEPTION(0);
12930   }
12931
12932   jresult = result;
12933   return jresult;
12934 }
12935
12936
12937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_NotifySignal(void * jarg1) {
12938   void * jresult ;
12939   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
12940   Dali::PropertyNotifySignalType *result = 0 ;
12941
12942   arg1 = (Dali::PropertyNotification *)jarg1;
12943   {
12944     try {
12945       result = (Dali::PropertyNotifySignalType *) &(arg1)->NotifySignal();
12946     } CALL_CATCH_EXCEPTION(0);
12947   }
12948
12949   jresult = (void *)result;
12950   return jresult;
12951 }
12952
12953
12954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_0() {
12955   void * jresult ;
12956   Dali::Handle *result = 0 ;
12957
12958   {
12959     try {
12960       result = (Dali::Handle *)new Dali::Handle();
12961     } CALL_CATCH_EXCEPTION(0);
12962   }
12963
12964   jresult = (void *)result;
12965   return jresult;
12966 }
12967
12968
12969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_New() {
12970   void * jresult ;
12971   Dali::Handle result;
12972
12973   {
12974     try {
12975       result = Dali::Handle::New();
12976     } CALL_CATCH_EXCEPTION(0);
12977   }
12978
12979   jresult = new Dali::Handle((const Dali::Handle &)result);
12980   return jresult;
12981 }
12982
12983
12984 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Handle(void * jarg1) {
12985   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
12986
12987   arg1 = (Dali::Handle *)jarg1;
12988   {
12989     try {
12990       delete arg1;
12991     } CALL_CATCH_EXCEPTION();
12992   }
12993
12994 }
12995
12996
12997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_1(void * jarg1) {
12998   void * jresult ;
12999   Dali::Handle *arg1 = 0 ;
13000   Dali::Handle *result = 0 ;
13001
13002   arg1 = (Dali::Handle *)jarg1;
13003   if (!arg1) {
13004     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
13005     return 0;
13006   }
13007   {
13008     try {
13009       result = (Dali::Handle *)new Dali::Handle((Dali::Handle const &)*arg1);
13010     } CALL_CATCH_EXCEPTION(0);
13011   }
13012
13013   jresult = (void *)result;
13014   return jresult;
13015 }
13016
13017
13018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_Assign(void * jarg1, void * jarg2) {
13019   void * jresult ;
13020   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13021   Dali::Handle *arg2 = 0 ;
13022   Dali::Handle *result = 0 ;
13023
13024   arg1 = (Dali::Handle *)jarg1;
13025   arg2 = (Dali::Handle *)jarg2;
13026   if (!arg2) {
13027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
13028     return 0;
13029   }
13030   {
13031     try {
13032       result = (Dali::Handle *) &(arg1)->operator =((Dali::Handle const &)*arg2);
13033     } CALL_CATCH_EXCEPTION(0);
13034   }
13035
13036   jresult = (void *)result;
13037   return jresult;
13038 }
13039
13040
13041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_DownCast(void * jarg1) {
13042   void * jresult ;
13043   Dali::BaseHandle arg1 ;
13044   Dali::BaseHandle *argp1 ;
13045   Dali::Handle result;
13046
13047   argp1 = (Dali::BaseHandle *)jarg1;
13048   if (!argp1) {
13049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
13050     return 0;
13051   }
13052   arg1 = *argp1;
13053   {
13054     try {
13055       result = Dali::Handle::DownCast(arg1);
13056     } CALL_CATCH_EXCEPTION(0);
13057   }
13058
13059   jresult = new Dali::Handle((const Dali::Handle &)result);
13060   return jresult;
13061 }
13062
13063
13064 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_Supports(void * jarg1, int jarg2) {
13065   unsigned int jresult ;
13066   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13067   Dali::Handle::Capability arg2 ;
13068   bool result;
13069
13070   arg1 = (Dali::Handle *)jarg1;
13071   arg2 = (Dali::Handle::Capability)jarg2;
13072   {
13073     try {
13074       result = (bool)((Dali::Handle const *)arg1)->Supports(arg2);
13075     } CALL_CATCH_EXCEPTION(0);
13076   }
13077
13078   jresult = result;
13079   return jresult;
13080 }
13081
13082
13083 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyCount(void * jarg1) {
13084   unsigned int jresult ;
13085   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13086   unsigned int result;
13087
13088   arg1 = (Dali::Handle *)jarg1;
13089   {
13090     try {
13091       result = (unsigned int)((Dali::Handle const *)arg1)->GetPropertyCount();
13092     } CALL_CATCH_EXCEPTION(0);
13093   }
13094
13095   jresult = result;
13096   return jresult;
13097 }
13098
13099
13100 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Handle_GetPropertyName(void * jarg1, int jarg2) {
13101   char * jresult ;
13102   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13103   Dali::Property::Index arg2 ;
13104   std::string result;
13105
13106   arg1 = (Dali::Handle *)jarg1;
13107   arg2 = (Dali::Property::Index)jarg2;
13108   {
13109     try {
13110       result = ((Dali::Handle const *)arg1)->GetPropertyName(arg2);
13111     } CALL_CATCH_EXCEPTION(0);
13112   }
13113
13114   jresult = SWIG_csharp_string_callback((&result)->c_str());
13115   return jresult;
13116 }
13117
13118
13119 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndex(void * jarg1, char * jarg2) {
13120   int jresult ;
13121   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13122   std::string *arg2 = 0 ;
13123   Dali::Property::Index result;
13124
13125   arg1 = (Dali::Handle *)jarg1;
13126   if (!jarg2) {
13127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13128     return 0;
13129   }
13130   std::string arg2_str(jarg2);
13131   arg2 = &arg2_str;
13132   {
13133     try {
13134       result = (Dali::Property::Index)((Dali::Handle const *)arg1)->GetPropertyIndex((std::string const &)*arg2);
13135     } CALL_CATCH_EXCEPTION(0);
13136   }
13137
13138   jresult = result;
13139
13140   //argout typemap for const std::string&
13141
13142   return jresult;
13143 }
13144
13145
13146 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyWritable(void * jarg1, int jarg2) {
13147   unsigned int jresult ;
13148   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13149   Dali::Property::Index arg2 ;
13150   bool result;
13151
13152   arg1 = (Dali::Handle *)jarg1;
13153   arg2 = (Dali::Property::Index)jarg2;
13154   {
13155     try {
13156       result = (bool)((Dali::Handle const *)arg1)->IsPropertyWritable(arg2);
13157     } CALL_CATCH_EXCEPTION(0);
13158   }
13159
13160   jresult = result;
13161   return jresult;
13162 }
13163
13164
13165 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAnimatable(void * jarg1, int jarg2) {
13166   unsigned int jresult ;
13167   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13168   Dali::Property::Index arg2 ;
13169   bool result;
13170
13171   arg1 = (Dali::Handle *)jarg1;
13172   arg2 = (Dali::Property::Index)jarg2;
13173   {
13174     try {
13175       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAnimatable(arg2);
13176     } CALL_CATCH_EXCEPTION(0);
13177   }
13178
13179   jresult = result;
13180   return jresult;
13181 }
13182
13183
13184 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAConstraintInput(void * jarg1, int jarg2) {
13185   unsigned int jresult ;
13186   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13187   Dali::Property::Index arg2 ;
13188   bool result;
13189
13190   arg1 = (Dali::Handle *)jarg1;
13191   arg2 = (Dali::Property::Index)jarg2;
13192   {
13193     try {
13194       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAConstraintInput(arg2);
13195     } CALL_CATCH_EXCEPTION(0);
13196   }
13197
13198   jresult = result;
13199   return jresult;
13200 }
13201
13202
13203 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyType(void * jarg1, int jarg2) {
13204   int jresult ;
13205   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13206   Dali::Property::Index arg2 ;
13207   Dali::Property::Type result;
13208
13209   arg1 = (Dali::Handle *)jarg1;
13210   arg2 = (Dali::Property::Index)jarg2;
13211   {
13212     try {
13213       result = (Dali::Property::Type)((Dali::Handle const *)arg1)->GetPropertyType(arg2);
13214     } CALL_CATCH_EXCEPTION(0);
13215   }
13216
13217   jresult = (int)result;
13218   return jresult;
13219 }
13220
13221
13222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_SetProperty(void * jarg1, int jarg2, void * jarg3) {
13223   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13224   Dali::Property::Index arg2 ;
13225   Dali::Property::Value *arg3 = 0 ;
13226
13227   arg1 = (Dali::Handle *)jarg1;
13228   arg2 = (Dali::Property::Index)jarg2;
13229   arg3 = (Dali::Property::Value *)jarg3;
13230   if (!arg3) {
13231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
13232     return ;
13233   }
13234   {
13235     try {
13236       (arg1)->SetProperty(arg2,(Dali::Property::Value const &)*arg3);
13237     } CALL_CATCH_EXCEPTION();
13238   }
13239
13240 }
13241
13242
13243 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
13244   int jresult ;
13245   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13246   std::string *arg2 = 0 ;
13247   Dali::Property::Value *arg3 = 0 ;
13248   Dali::Property::Index result;
13249
13250   arg1 = (Dali::Handle *)jarg1;
13251   if (!jarg2) {
13252     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13253     return 0;
13254   }
13255   std::string arg2_str(jarg2);
13256   arg2 = &arg2_str;
13257   arg3 = (Dali::Property::Value *)jarg3;
13258   if (!arg3) {
13259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
13260     return 0;
13261   }
13262   {
13263     try {
13264       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
13265     } CALL_CATCH_EXCEPTION(0);
13266   }
13267
13268   jresult = result;
13269
13270   //argout typemap for const std::string&
13271
13272   return jresult;
13273 }
13274
13275
13276 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_1(void * jarg1, char * jarg2, void * jarg3, int jarg4) {
13277   int jresult ;
13278   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13279   std::string *arg2 = 0 ;
13280   Dali::Property::Value *arg3 = 0 ;
13281   Dali::Property::AccessMode arg4 ;
13282   Dali::Property::Index result;
13283
13284   arg1 = (Dali::Handle *)jarg1;
13285   if (!jarg2) {
13286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13287     return 0;
13288   }
13289   std::string arg2_str(jarg2);
13290   arg2 = &arg2_str;
13291   arg3 = (Dali::Property::Value *)jarg3;
13292   if (!arg3) {
13293     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
13294     return 0;
13295   }
13296   arg4 = (Dali::Property::AccessMode)jarg4;
13297   {
13298     try {
13299       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3,arg4);
13300     } CALL_CATCH_EXCEPTION(0);
13301   }
13302
13303   jresult = result;
13304
13305   //argout typemap for const std::string&
13306
13307   return jresult;
13308 }
13309
13310
13311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_GetProperty(void * jarg1, int jarg2) {
13312   void * jresult ;
13313   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13314   Dali::Property::Index arg2 ;
13315   Dali::Property::Value result;
13316
13317   arg1 = (Dali::Handle *)jarg1;
13318   arg2 = (Dali::Property::Index)jarg2;
13319   {
13320     try {
13321       result = ((Dali::Handle const *)arg1)->GetProperty(arg2);
13322     } CALL_CATCH_EXCEPTION(0);
13323   }
13324
13325   jresult = new Dali::Property::Value((const Dali::Property::Value &)result);
13326   return jresult;
13327 }
13328
13329
13330 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndices(void * jarg1, void * jarg2) {
13331   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13332   Dali::Property::IndexContainer *arg2 = 0 ;
13333
13334   arg1 = (Dali::Handle *)jarg1;
13335   arg2 = (Dali::Property::IndexContainer *)jarg2;
13336   if (!arg2) {
13337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
13338     return ;
13339   }
13340   {
13341     try {
13342       ((Dali::Handle const *)arg1)->GetPropertyIndices(*arg2);
13343     } CALL_CATCH_EXCEPTION();
13344   }
13345
13346 }
13347
13348
13349 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_0(void * jarg1, int jarg2, void * jarg3) {
13350   void * jresult ;
13351   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13352   Dali::Property::Index arg2 ;
13353   Dali::PropertyCondition *arg3 = 0 ;
13354   Dali::PropertyNotification result;
13355
13356   arg1 = (Dali::Handle *)jarg1;
13357   arg2 = (Dali::Property::Index)jarg2;
13358   arg3 = (Dali::PropertyCondition *)jarg3;
13359   if (!arg3) {
13360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
13361     return 0;
13362   }
13363   {
13364     try {
13365       result = (arg1)->AddPropertyNotification(arg2,(Dali::PropertyCondition const &)*arg3);
13366     } CALL_CATCH_EXCEPTION(0);
13367   }
13368
13369   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
13370   return jresult;
13371 }
13372
13373
13374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_1(void * jarg1, int jarg2, int jarg3, void * jarg4) {
13375   void * jresult ;
13376   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13377   Dali::Property::Index arg2 ;
13378   int arg3 ;
13379   Dali::PropertyCondition *arg4 = 0 ;
13380   Dali::PropertyNotification result;
13381
13382   arg1 = (Dali::Handle *)jarg1;
13383   arg2 = (Dali::Property::Index)jarg2;
13384   arg3 = (int)jarg3;
13385   arg4 = (Dali::PropertyCondition *)jarg4;
13386   if (!arg4) {
13387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
13388     return 0;
13389   }
13390   {
13391     try {
13392       result = (arg1)->AddPropertyNotification(arg2,arg3,(Dali::PropertyCondition const &)*arg4);
13393     } CALL_CATCH_EXCEPTION(0);
13394   }
13395
13396   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
13397   return jresult;
13398 }
13399
13400
13401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotification(void * jarg1, void * jarg2) {
13402   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13403   Dali::PropertyNotification arg2 ;
13404   Dali::PropertyNotification *argp2 ;
13405
13406   arg1 = (Dali::Handle *)jarg1;
13407   argp2 = (Dali::PropertyNotification *)jarg2;
13408   if (!argp2) {
13409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PropertyNotification", 0);
13410     return ;
13411   }
13412   arg2 = *argp2;
13413   {
13414     try {
13415       (arg1)->RemovePropertyNotification(arg2);
13416     } CALL_CATCH_EXCEPTION();
13417   }
13418
13419 }
13420
13421
13422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotifications(void * jarg1) {
13423   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13424
13425   arg1 = (Dali::Handle *)jarg1;
13426   {
13427     try {
13428       (arg1)->RemovePropertyNotifications();
13429     } CALL_CATCH_EXCEPTION();
13430   }
13431
13432 }
13433
13434
13435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_0(void * jarg1) {
13436   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13437
13438   arg1 = (Dali::Handle *)jarg1;
13439   {
13440     try {
13441       (arg1)->RemoveConstraints();
13442     } CALL_CATCH_EXCEPTION();
13443   }
13444
13445 }
13446
13447
13448 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_1(void * jarg1, unsigned int jarg2) {
13449   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
13450   unsigned int arg2 ;
13451
13452   arg1 = (Dali::Handle *)jarg1;
13453   arg2 = (unsigned int)jarg2;
13454   {
13455     try {
13456       (arg1)->RemoveConstraints(arg2);
13457     } CALL_CATCH_EXCEPTION();
13458   }
13459
13460 }
13461
13462
13463 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WEIGHT_get() {
13464   int jresult ;
13465   Dali::Property::Index result;
13466
13467   result = (Dali::Property::Index)(Dali::Property::Index)Dali::WeightObject::WEIGHT;
13468   jresult = result;
13469   return jresult;
13470 }
13471
13472
13473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_New() {
13474   void * jresult ;
13475   Dali::Handle result;
13476
13477   {
13478     try {
13479       result = Dali::WeightObject::New();
13480     } CALL_CATCH_EXCEPTION(0);
13481   }
13482
13483   jresult = new Dali::Handle((const Dali::Handle &)result);
13484   return jresult;
13485 }
13486
13487
13488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_0() {
13489   void * jresult ;
13490   Dali::TypeInfo *result = 0 ;
13491
13492   {
13493     try {
13494       result = (Dali::TypeInfo *)new Dali::TypeInfo();
13495     } CALL_CATCH_EXCEPTION(0);
13496   }
13497
13498   jresult = (void *)result;
13499   return jresult;
13500 }
13501
13502
13503 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeInfo(void * jarg1) {
13504   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13505
13506   arg1 = (Dali::TypeInfo *)jarg1;
13507   {
13508     try {
13509       delete arg1;
13510     } CALL_CATCH_EXCEPTION();
13511   }
13512
13513 }
13514
13515
13516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_1(void * jarg1) {
13517   void * jresult ;
13518   Dali::TypeInfo *arg1 = 0 ;
13519   Dali::TypeInfo *result = 0 ;
13520
13521   arg1 = (Dali::TypeInfo *)jarg1;
13522   if (!arg1) {
13523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
13524     return 0;
13525   }
13526   {
13527     try {
13528       result = (Dali::TypeInfo *)new Dali::TypeInfo((Dali::TypeInfo const &)*arg1);
13529     } CALL_CATCH_EXCEPTION(0);
13530   }
13531
13532   jresult = (void *)result;
13533   return jresult;
13534 }
13535
13536
13537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_Assign(void * jarg1, void * jarg2) {
13538   void * jresult ;
13539   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13540   Dali::TypeInfo *arg2 = 0 ;
13541   Dali::TypeInfo *result = 0 ;
13542
13543   arg1 = (Dali::TypeInfo *)jarg1;
13544   arg2 = (Dali::TypeInfo *)jarg2;
13545   if (!arg2) {
13546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
13547     return 0;
13548   }
13549   {
13550     try {
13551       result = (Dali::TypeInfo *) &(arg1)->operator =((Dali::TypeInfo const &)*arg2);
13552     } CALL_CATCH_EXCEPTION(0);
13553   }
13554
13555   jresult = (void *)result;
13556   return jresult;
13557 }
13558
13559
13560 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetName(void * jarg1) {
13561   char * jresult ;
13562   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13563   std::string *result = 0 ;
13564
13565   arg1 = (Dali::TypeInfo *)jarg1;
13566   {
13567     try {
13568       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetName();
13569     } CALL_CATCH_EXCEPTION(0);
13570   }
13571
13572   jresult = SWIG_csharp_string_callback(result->c_str());
13573   return jresult;
13574 }
13575
13576
13577 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetBaseName(void * jarg1) {
13578   char * jresult ;
13579   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13580   std::string *result = 0 ;
13581
13582   arg1 = (Dali::TypeInfo *)jarg1;
13583   {
13584     try {
13585       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetBaseName();
13586     } CALL_CATCH_EXCEPTION(0);
13587   }
13588
13589   jresult = SWIG_csharp_string_callback(result->c_str());
13590   return jresult;
13591 }
13592
13593
13594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_CreateInstance(void * jarg1) {
13595   void * jresult ;
13596   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13597   Dali::BaseHandle result;
13598
13599   arg1 = (Dali::TypeInfo *)jarg1;
13600   {
13601     try {
13602       result = ((Dali::TypeInfo const *)arg1)->CreateInstance();
13603     } CALL_CATCH_EXCEPTION(0);
13604   }
13605
13606   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
13607   return jresult;
13608 }
13609
13610
13611 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionCount(void * jarg1) {
13612   unsigned long jresult ;
13613   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13614   size_t result;
13615
13616   arg1 = (Dali::TypeInfo *)jarg1;
13617   {
13618     try {
13619       result = ((Dali::TypeInfo const *)arg1)->GetActionCount();
13620     } CALL_CATCH_EXCEPTION(0);
13621   }
13622
13623   jresult = (unsigned long)result;
13624   return jresult;
13625 }
13626
13627
13628 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionName(void * jarg1, unsigned long jarg2) {
13629   char * jresult ;
13630   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13631   size_t arg2 ;
13632   std::string result;
13633
13634   arg1 = (Dali::TypeInfo *)jarg1;
13635   arg2 = (size_t)jarg2;
13636   {
13637     try {
13638       result = (arg1)->GetActionName(arg2);
13639     } CALL_CATCH_EXCEPTION(0);
13640   }
13641
13642   jresult = SWIG_csharp_string_callback((&result)->c_str());
13643   return jresult;
13644 }
13645
13646
13647 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalCount(void * jarg1) {
13648   unsigned long jresult ;
13649   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13650   size_t result;
13651
13652   arg1 = (Dali::TypeInfo *)jarg1;
13653   {
13654     try {
13655       result = ((Dali::TypeInfo const *)arg1)->GetSignalCount();
13656     } CALL_CATCH_EXCEPTION(0);
13657   }
13658
13659   jresult = (unsigned long)result;
13660   return jresult;
13661 }
13662
13663
13664 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalName(void * jarg1, unsigned long jarg2) {
13665   char * jresult ;
13666   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13667   size_t arg2 ;
13668   std::string result;
13669
13670   arg1 = (Dali::TypeInfo *)jarg1;
13671   arg2 = (size_t)jarg2;
13672   {
13673     try {
13674       result = (arg1)->GetSignalName(arg2);
13675     } CALL_CATCH_EXCEPTION(0);
13676   }
13677
13678   jresult = SWIG_csharp_string_callback((&result)->c_str());
13679   return jresult;
13680 }
13681
13682
13683 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyCount(void * jarg1) {
13684   unsigned long jresult ;
13685   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13686   size_t result;
13687
13688   arg1 = (Dali::TypeInfo *)jarg1;
13689   {
13690     try {
13691       result = ((Dali::TypeInfo const *)arg1)->GetPropertyCount();
13692     } CALL_CATCH_EXCEPTION(0);
13693   }
13694
13695   jresult = (unsigned long)result;
13696   return jresult;
13697 }
13698
13699
13700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyIndices(void * jarg1, void * jarg2) {
13701   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13702   Dali::Property::IndexContainer *arg2 = 0 ;
13703
13704   arg1 = (Dali::TypeInfo *)jarg1;
13705   arg2 = (Dali::Property::IndexContainer *)jarg2;
13706   if (!arg2) {
13707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
13708     return ;
13709   }
13710   {
13711     try {
13712       ((Dali::TypeInfo const *)arg1)->GetPropertyIndices(*arg2);
13713     } CALL_CATCH_EXCEPTION();
13714   }
13715
13716 }
13717
13718
13719 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyName(void * jarg1, int jarg2) {
13720   char * jresult ;
13721   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
13722   Dali::Property::Index arg2 ;
13723   std::string *result = 0 ;
13724
13725   arg1 = (Dali::TypeInfo *)jarg1;
13726   arg2 = (Dali::Property::Index)jarg2;
13727   {
13728     try {
13729       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetPropertyName(arg2);
13730     } CALL_CATCH_EXCEPTION(0);
13731   }
13732
13733   jresult = SWIG_csharp_string_callback(result->c_str());
13734   return jresult;
13735 }
13736
13737
13738 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Get() {
13739   void * jresult ;
13740   Dali::TypeRegistry result;
13741
13742   {
13743     try {
13744       result = Dali::TypeRegistry::Get();
13745     } CALL_CATCH_EXCEPTION(0);
13746   }
13747
13748   jresult = new Dali::TypeRegistry((const Dali::TypeRegistry &)result);
13749   return jresult;
13750 }
13751
13752
13753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_0() {
13754   void * jresult ;
13755   Dali::TypeRegistry *result = 0 ;
13756
13757   {
13758     try {
13759       result = (Dali::TypeRegistry *)new Dali::TypeRegistry();
13760     } CALL_CATCH_EXCEPTION(0);
13761   }
13762
13763   jresult = (void *)result;
13764   return jresult;
13765 }
13766
13767
13768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistry(void * jarg1) {
13769   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
13770
13771   arg1 = (Dali::TypeRegistry *)jarg1;
13772   {
13773     try {
13774       delete arg1;
13775     } CALL_CATCH_EXCEPTION();
13776   }
13777
13778 }
13779
13780
13781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_1(void * jarg1) {
13782   void * jresult ;
13783   Dali::TypeRegistry *arg1 = 0 ;
13784   Dali::TypeRegistry *result = 0 ;
13785
13786   arg1 = (Dali::TypeRegistry *)jarg1;
13787   if (!arg1) {
13788     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
13789     return 0;
13790   }
13791   {
13792     try {
13793       result = (Dali::TypeRegistry *)new Dali::TypeRegistry((Dali::TypeRegistry const &)*arg1);
13794     } CALL_CATCH_EXCEPTION(0);
13795   }
13796
13797   jresult = (void *)result;
13798   return jresult;
13799 }
13800
13801
13802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Assign(void * jarg1, void * jarg2) {
13803   void * jresult ;
13804   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
13805   Dali::TypeRegistry *arg2 = 0 ;
13806   Dali::TypeRegistry *result = 0 ;
13807
13808   arg1 = (Dali::TypeRegistry *)jarg1;
13809   arg2 = (Dali::TypeRegistry *)jarg2;
13810   if (!arg2) {
13811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
13812     return 0;
13813   }
13814   {
13815     try {
13816       result = (Dali::TypeRegistry *) &(arg1)->operator =((Dali::TypeRegistry const &)*arg2);
13817     } CALL_CATCH_EXCEPTION(0);
13818   }
13819
13820   jresult = (void *)result;
13821   return jresult;
13822 }
13823
13824
13825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_0(void * jarg1, char * jarg2) {
13826   void * jresult ;
13827   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
13828   std::string *arg2 = 0 ;
13829   Dali::TypeInfo result;
13830
13831   arg1 = (Dali::TypeRegistry *)jarg1;
13832   if (!jarg2) {
13833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13834     return 0;
13835   }
13836   std::string arg2_str(jarg2);
13837   arg2 = &arg2_str;
13838   {
13839     try {
13840       result = (arg1)->GetTypeInfo((std::string const &)*arg2);
13841     } CALL_CATCH_EXCEPTION(0);
13842   }
13843
13844   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
13845
13846   //argout typemap for const std::string&
13847
13848   return jresult;
13849 }
13850
13851
13852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_1(void * jarg1, void * jarg2) {
13853   void * jresult ;
13854   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
13855   std::type_info *arg2 = 0 ;
13856   Dali::TypeInfo result;
13857
13858   arg1 = (Dali::TypeRegistry *)jarg1;
13859   arg2 = (std::type_info *)jarg2;
13860   if (!arg2) {
13861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
13862     return 0;
13863   }
13864   {
13865     try {
13866       result = (arg1)->GetTypeInfo((std::type_info const &)*arg2);
13867     } CALL_CATCH_EXCEPTION(0);
13868   }
13869
13870   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
13871   return jresult;
13872 }
13873
13874
13875 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeNameCount(void * jarg1) {
13876   unsigned long jresult ;
13877   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
13878   size_t result;
13879
13880   arg1 = (Dali::TypeRegistry *)jarg1;
13881   {
13882     try {
13883       result = ((Dali::TypeRegistry const *)arg1)->GetTypeNameCount();
13884     } CALL_CATCH_EXCEPTION(0);
13885   }
13886
13887   jresult = (unsigned long)result;
13888   return jresult;
13889 }
13890
13891
13892 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeName(void * jarg1, unsigned long jarg2) {
13893   char * jresult ;
13894   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
13895   size_t arg2 ;
13896   std::string result;
13897
13898   arg1 = (Dali::TypeRegistry *)jarg1;
13899   arg2 = (size_t)jarg2;
13900   {
13901     try {
13902       result = ((Dali::TypeRegistry const *)arg1)->GetTypeName(arg2);
13903     } CALL_CATCH_EXCEPTION(0);
13904   }
13905
13906   jresult = SWIG_csharp_string_callback((&result)->c_str());
13907   return jresult;
13908 }
13909
13910
13911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
13912   void * jresult ;
13913   std::type_info *arg1 = 0 ;
13914   std::type_info *arg2 = 0 ;
13915   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
13916   Dali::TypeRegistration *result = 0 ;
13917
13918   arg1 = (std::type_info *)jarg1;
13919   if (!arg1) {
13920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
13921     return 0;
13922   }
13923   arg2 = (std::type_info *)jarg2;
13924   if (!arg2) {
13925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
13926     return 0;
13927   }
13928   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
13929   {
13930     try {
13931       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3);
13932     } CALL_CATCH_EXCEPTION(0);
13933   }
13934
13935   jresult = (void *)result;
13936   return jresult;
13937 }
13938
13939
13940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_1(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
13941   void * jresult ;
13942   std::type_info *arg1 = 0 ;
13943   std::type_info *arg2 = 0 ;
13944   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
13945   bool arg4 ;
13946   Dali::TypeRegistration *result = 0 ;
13947
13948   arg1 = (std::type_info *)jarg1;
13949   if (!arg1) {
13950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
13951     return 0;
13952   }
13953   arg2 = (std::type_info *)jarg2;
13954   if (!arg2) {
13955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
13956     return 0;
13957   }
13958   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
13959   arg4 = jarg4 ? true : false;
13960   {
13961     try {
13962       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3,arg4);
13963     } CALL_CATCH_EXCEPTION(0);
13964   }
13965
13966   jresult = (void *)result;
13967   return jresult;
13968 }
13969
13970
13971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_2(char * jarg1, void * jarg2, void * jarg3) {
13972   void * jresult ;
13973   std::string *arg1 = 0 ;
13974   std::type_info *arg2 = 0 ;
13975   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
13976   Dali::TypeRegistration *result = 0 ;
13977
13978   if (!jarg1) {
13979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13980     return 0;
13981   }
13982   std::string arg1_str(jarg1);
13983   arg1 = &arg1_str;
13984   arg2 = (std::type_info *)jarg2;
13985   if (!arg2) {
13986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
13987     return 0;
13988   }
13989   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
13990   {
13991     try {
13992       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
13993     } CALL_CATCH_EXCEPTION(0);
13994   }
13995
13996   jresult = (void *)result;
13997
13998   //argout typemap for const std::string&
13999
14000   return jresult;
14001 }
14002
14003
14004 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisteredName(void * jarg1) {
14005   char * jresult ;
14006   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
14007   std::string result;
14008
14009   arg1 = (Dali::TypeRegistration *)jarg1;
14010   {
14011     try {
14012       result = ((Dali::TypeRegistration const *)arg1)->RegisteredName();
14013     } CALL_CATCH_EXCEPTION(0);
14014   }
14015
14016   jresult = SWIG_csharp_string_callback((&result)->c_str());
14017   return jresult;
14018 }
14019
14020
14021 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterControl(char * jarg1, void * jarg2) {
14022   std::string *arg1 = 0 ;
14023   Dali::CSharpTypeInfo::CreateFunction arg2 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
14024
14025   if (!jarg1) {
14026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14027     return ;
14028   }
14029   std::string arg1_str(jarg1);
14030   arg1 = &arg1_str;
14031   arg2 = (Dali::CSharpTypeInfo::CreateFunction)jarg2;
14032   {
14033     try {
14034       Dali_TypeRegistration_RegisterControl((std::string const &)*arg1,arg2);
14035     } CALL_CATCH_EXCEPTION();
14036   }
14037
14038
14039   //argout typemap for const std::string&
14040
14041 }
14042
14043
14044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
14045   std::string *arg1 = 0 ;
14046   std::string *arg2 = 0 ;
14047   int arg3 ;
14048   Dali::Property::Type arg4 ;
14049   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
14050   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
14051
14052   if (!jarg1) {
14053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14054     return ;
14055   }
14056   std::string arg1_str(jarg1);
14057   arg1 = &arg1_str;
14058   if (!jarg2) {
14059     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14060     return ;
14061   }
14062   std::string arg2_str(jarg2);
14063   arg2 = &arg2_str;
14064   arg3 = (int)jarg3;
14065   arg4 = (Dali::Property::Type)jarg4;
14066   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
14067   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
14068   {
14069     try {
14070       Dali_TypeRegistration_RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
14071     } CALL_CATCH_EXCEPTION();
14072   }
14073
14074
14075   //argout typemap for const std::string&
14076
14077
14078   //argout typemap for const std::string&
14079
14080 }
14081
14082
14083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistration(void * jarg1) {
14084   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
14085
14086   arg1 = (Dali::TypeRegistration *)jarg1;
14087   {
14088     try {
14089       delete arg1;
14090     } CALL_CATCH_EXCEPTION();
14091   }
14092
14093 }
14094
14095
14096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SignalConnectorType(void * jarg1, char * jarg2, void * jarg3) {
14097   void * jresult ;
14098   Dali::TypeRegistration *arg1 = 0 ;
14099   std::string *arg2 = 0 ;
14100   Dali::TypeInfo::SignalConnectorFunction arg3 = (Dali::TypeInfo::SignalConnectorFunction) 0 ;
14101   Dali::SignalConnectorType *result = 0 ;
14102
14103   arg1 = (Dali::TypeRegistration *)jarg1;
14104   if (!arg1) {
14105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
14106     return 0;
14107   }
14108   if (!jarg2) {
14109     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14110     return 0;
14111   }
14112   std::string arg2_str(jarg2);
14113   arg2 = &arg2_str;
14114   arg3 = (Dali::TypeInfo::SignalConnectorFunction)jarg3;
14115   {
14116     try {
14117       result = (Dali::SignalConnectorType *)new Dali::SignalConnectorType(*arg1,(std::string const &)*arg2,arg3);
14118     } CALL_CATCH_EXCEPTION(0);
14119   }
14120
14121   jresult = (void *)result;
14122
14123   //argout typemap for const std::string&
14124
14125   return jresult;
14126 }
14127
14128
14129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalConnectorType(void * jarg1) {
14130   Dali::SignalConnectorType *arg1 = (Dali::SignalConnectorType *) 0 ;
14131
14132   arg1 = (Dali::SignalConnectorType *)jarg1;
14133   {
14134     try {
14135       delete arg1;
14136     } CALL_CATCH_EXCEPTION();
14137   }
14138
14139 }
14140
14141
14142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeAction(void * jarg1, char * jarg2, void * jarg3) {
14143   void * jresult ;
14144   Dali::TypeRegistration *arg1 = 0 ;
14145   std::string *arg2 = 0 ;
14146   Dali::TypeInfo::ActionFunction arg3 = (Dali::TypeInfo::ActionFunction) 0 ;
14147   Dali::TypeAction *result = 0 ;
14148
14149   arg1 = (Dali::TypeRegistration *)jarg1;
14150   if (!arg1) {
14151     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
14152     return 0;
14153   }
14154   if (!jarg2) {
14155     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14156     return 0;
14157   }
14158   std::string arg2_str(jarg2);
14159   arg2 = &arg2_str;
14160   arg3 = (Dali::TypeInfo::ActionFunction)jarg3;
14161   {
14162     try {
14163       result = (Dali::TypeAction *)new Dali::TypeAction(*arg1,(std::string const &)*arg2,arg3);
14164     } CALL_CATCH_EXCEPTION(0);
14165   }
14166
14167   jresult = (void *)result;
14168
14169   //argout typemap for const std::string&
14170
14171   return jresult;
14172 }
14173
14174
14175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeAction(void * jarg1) {
14176   Dali::TypeAction *arg1 = (Dali::TypeAction *) 0 ;
14177
14178   arg1 = (Dali::TypeAction *)jarg1;
14179   {
14180     try {
14181       delete arg1;
14182     } CALL_CATCH_EXCEPTION();
14183   }
14184
14185 }
14186
14187
14188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
14189   void * jresult ;
14190   Dali::TypeRegistration *arg1 = 0 ;
14191   std::string *arg2 = 0 ;
14192   Dali::Property::Index arg3 ;
14193   Dali::Property::Type arg4 ;
14194   Dali::TypeInfo::SetPropertyFunction arg5 = (Dali::TypeInfo::SetPropertyFunction) 0 ;
14195   Dali::TypeInfo::GetPropertyFunction arg6 = (Dali::TypeInfo::GetPropertyFunction) 0 ;
14196   Dali::PropertyRegistration *result = 0 ;
14197
14198   arg1 = (Dali::TypeRegistration *)jarg1;
14199   if (!arg1) {
14200     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
14201     return 0;
14202   }
14203   if (!jarg2) {
14204     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14205     return 0;
14206   }
14207   std::string arg2_str(jarg2);
14208   arg2 = &arg2_str;
14209   arg3 = (Dali::Property::Index)jarg3;
14210   arg4 = (Dali::Property::Type)jarg4;
14211   arg5 = (Dali::TypeInfo::SetPropertyFunction)jarg5;
14212   arg6 = (Dali::TypeInfo::GetPropertyFunction)jarg6;
14213   {
14214     try {
14215       result = (Dali::PropertyRegistration *)new Dali::PropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
14216     } CALL_CATCH_EXCEPTION(0);
14217   }
14218
14219   jresult = (void *)result;
14220
14221   //argout typemap for const std::string&
14222
14223   return jresult;
14224 }
14225
14226
14227 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyRegistration(void * jarg1) {
14228   Dali::PropertyRegistration *arg1 = (Dali::PropertyRegistration *) 0 ;
14229
14230   arg1 = (Dali::PropertyRegistration *)jarg1;
14231   {
14232     try {
14233       delete arg1;
14234     } CALL_CATCH_EXCEPTION();
14235   }
14236
14237 }
14238
14239
14240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_0(void * jarg1, char * jarg2, int jarg3, int jarg4) {
14241   void * jresult ;
14242   Dali::TypeRegistration *arg1 = 0 ;
14243   std::string *arg2 = 0 ;
14244   Dali::Property::Index arg3 ;
14245   Dali::Property::Type arg4 ;
14246   Dali::AnimatablePropertyRegistration *result = 0 ;
14247
14248   arg1 = (Dali::TypeRegistration *)jarg1;
14249   if (!arg1) {
14250     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
14251     return 0;
14252   }
14253   if (!jarg2) {
14254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14255     return 0;
14256   }
14257   std::string arg2_str(jarg2);
14258   arg2 = &arg2_str;
14259   arg3 = (Dali::Property::Index)jarg3;
14260   arg4 = (Dali::Property::Type)jarg4;
14261   {
14262     try {
14263       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
14264     } CALL_CATCH_EXCEPTION(0);
14265   }
14266
14267   jresult = (void *)result;
14268
14269   //argout typemap for const std::string&
14270
14271   return jresult;
14272 }
14273
14274
14275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_1(void * jarg1, char * jarg2, int jarg3, void * jarg4) {
14276   void * jresult ;
14277   Dali::TypeRegistration *arg1 = 0 ;
14278   std::string *arg2 = 0 ;
14279   Dali::Property::Index arg3 ;
14280   Dali::Property::Value *arg4 = 0 ;
14281   Dali::AnimatablePropertyRegistration *result = 0 ;
14282
14283   arg1 = (Dali::TypeRegistration *)jarg1;
14284   if (!arg1) {
14285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
14286     return 0;
14287   }
14288   if (!jarg2) {
14289     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14290     return 0;
14291   }
14292   std::string arg2_str(jarg2);
14293   arg2 = &arg2_str;
14294   arg3 = (Dali::Property::Index)jarg3;
14295   arg4 = (Dali::Property::Value *)jarg4;
14296   if (!arg4) {
14297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14298     return 0;
14299   }
14300   {
14301     try {
14302       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,(Dali::Property::Value const &)*arg4);
14303     } CALL_CATCH_EXCEPTION(0);
14304   }
14305
14306   jresult = (void *)result;
14307
14308   //argout typemap for const std::string&
14309
14310   return jresult;
14311 }
14312
14313
14314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyRegistration(void * jarg1) {
14315   Dali::AnimatablePropertyRegistration *arg1 = (Dali::AnimatablePropertyRegistration *) 0 ;
14316
14317   arg1 = (Dali::AnimatablePropertyRegistration *)jarg1;
14318   {
14319     try {
14320       delete arg1;
14321     } CALL_CATCH_EXCEPTION();
14322   }
14323
14324 }
14325
14326
14327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyComponentRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
14328   void * jresult ;
14329   Dali::TypeRegistration *arg1 = 0 ;
14330   std::string *arg2 = 0 ;
14331   Dali::Property::Index arg3 ;
14332   Dali::Property::Index arg4 ;
14333   unsigned int arg5 ;
14334   Dali::AnimatablePropertyComponentRegistration *result = 0 ;
14335
14336   arg1 = (Dali::TypeRegistration *)jarg1;
14337   if (!arg1) {
14338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
14339     return 0;
14340   }
14341   if (!jarg2) {
14342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14343     return 0;
14344   }
14345   std::string arg2_str(jarg2);
14346   arg2 = &arg2_str;
14347   arg3 = (Dali::Property::Index)jarg3;
14348   arg4 = (Dali::Property::Index)jarg4;
14349   arg5 = (unsigned int)jarg5;
14350   {
14351     try {
14352       result = (Dali::AnimatablePropertyComponentRegistration *)new Dali::AnimatablePropertyComponentRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5);
14353     } CALL_CATCH_EXCEPTION(0);
14354   }
14355
14356   jresult = (void *)result;
14357
14358   //argout typemap for const std::string&
14359
14360   return jresult;
14361 }
14362
14363
14364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyComponentRegistration(void * jarg1) {
14365   Dali::AnimatablePropertyComponentRegistration *arg1 = (Dali::AnimatablePropertyComponentRegistration *) 0 ;
14366
14367   arg1 = (Dali::AnimatablePropertyComponentRegistration *)jarg1;
14368   {
14369     try {
14370       delete arg1;
14371     } CALL_CATCH_EXCEPTION();
14372   }
14373
14374 }
14375
14376
14377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ChildPropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4) {
14378   void * jresult ;
14379   Dali::TypeRegistration *arg1 = 0 ;
14380   std::string *arg2 = 0 ;
14381   Dali::Property::Index arg3 ;
14382   Dali::Property::Type arg4 ;
14383   Dali::ChildPropertyRegistration *result = 0 ;
14384
14385   arg1 = (Dali::TypeRegistration *)jarg1;
14386   if (!arg1) {
14387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
14388     return 0;
14389   }
14390   if (!jarg2) {
14391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14392     return 0;
14393   }
14394   std::string arg2_str(jarg2);
14395   arg2 = &arg2_str;
14396   arg3 = (Dali::Property::Index)jarg3;
14397   arg4 = (Dali::Property::Type)jarg4;
14398   {
14399     try {
14400       result = (Dali::ChildPropertyRegistration *)new Dali::ChildPropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
14401     } CALL_CATCH_EXCEPTION(0);
14402   }
14403
14404   jresult = (void *)result;
14405
14406   //argout typemap for const std::string&
14407
14408   return jresult;
14409 }
14410
14411
14412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ChildPropertyRegistration(void * jarg1) {
14413   Dali::ChildPropertyRegistration *arg1 = (Dali::ChildPropertyRegistration *) 0 ;
14414
14415   arg1 = (Dali::ChildPropertyRegistration *)jarg1;
14416   {
14417     try {
14418       delete arg1;
14419     } CALL_CATCH_EXCEPTION();
14420   }
14421
14422 }
14423
14424
14425 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterType(char * jarg1, void * jarg2, void * jarg3) {
14426   unsigned int jresult ;
14427   std::string *arg1 = 0 ;
14428   std::type_info *arg2 = 0 ;
14429   Dali::CSharpTypeInfo::CreateFunction arg3 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
14430   bool result;
14431
14432   if (!jarg1) {
14433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14434     return 0;
14435   }
14436   std::string arg1_str(jarg1);
14437   arg1 = &arg1_str;
14438   arg2 = (std::type_info *)jarg2;
14439   if (!arg2) {
14440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
14441     return 0;
14442   }
14443   arg3 = (Dali::CSharpTypeInfo::CreateFunction)jarg3;
14444   {
14445     try {
14446       result = (bool)Dali::CSharpTypeRegistry::RegisterType((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
14447     } CALL_CATCH_EXCEPTION(0);
14448   }
14449
14450   jresult = result;
14451
14452   //argout typemap for const std::string&
14453
14454   return jresult;
14455 }
14456
14457
14458 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
14459   unsigned int jresult ;
14460   std::string *arg1 = 0 ;
14461   std::string *arg2 = 0 ;
14462   Dali::Property::Index arg3 ;
14463   Dali::Property::Type arg4 ;
14464   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
14465   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
14466   bool result;
14467
14468   if (!jarg1) {
14469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14470     return 0;
14471   }
14472   std::string arg1_str(jarg1);
14473   arg1 = &arg1_str;
14474   if (!jarg2) {
14475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14476     return 0;
14477   }
14478   std::string arg2_str(jarg2);
14479   arg2 = &arg2_str;
14480   arg3 = (Dali::Property::Index)jarg3;
14481   arg4 = (Dali::Property::Type)jarg4;
14482   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
14483   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
14484   {
14485     try {
14486       result = (bool)Dali::CSharpTypeRegistry::RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
14487     } CALL_CATCH_EXCEPTION(0);
14488   }
14489
14490   jresult = result;
14491
14492   //argout typemap for const std::string&
14493
14494
14495   //argout typemap for const std::string&
14496
14497   return jresult;
14498 }
14499
14500
14501 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginTop_get() {
14502   float jresult ;
14503   float result;
14504
14505   result = (float)(float)Dali::ParentOrigin::TOP;
14506   jresult = result;
14507   return jresult;
14508 }
14509
14510
14511 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginBottom_get() {
14512   float jresult ;
14513   float result;
14514
14515   result = (float)(float)Dali::ParentOrigin::BOTTOM;
14516   jresult = result;
14517   return jresult;
14518 }
14519
14520
14521 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginLeft_get() {
14522   float jresult ;
14523   float result;
14524
14525   result = (float)(float)Dali::ParentOrigin::LEFT;
14526   jresult = result;
14527   return jresult;
14528 }
14529
14530
14531 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginRight_get() {
14532   float jresult ;
14533   float result;
14534
14535   result = (float)(float)Dali::ParentOrigin::RIGHT;
14536   jresult = result;
14537   return jresult;
14538 }
14539
14540
14541 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginMiddle_get() {
14542   float jresult ;
14543   float result;
14544
14545   result = (float)(float)Dali::ParentOrigin::MIDDLE;
14546   jresult = result;
14547   return jresult;
14548 }
14549
14550
14551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopLeft_get() {
14552   void * jresult ;
14553   Dali::Vector3 *result = 0 ;
14554
14555   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_LEFT;
14556   jresult = (void *)result;
14557   return jresult;
14558 }
14559
14560
14561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopCenter_get() {
14562   void * jresult ;
14563   Dali::Vector3 *result = 0 ;
14564
14565   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_CENTER;
14566   jresult = (void *)result;
14567   return jresult;
14568 }
14569
14570
14571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopRight_get() {
14572   void * jresult ;
14573   Dali::Vector3 *result = 0 ;
14574
14575   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_RIGHT;
14576   jresult = (void *)result;
14577   return jresult;
14578 }
14579
14580
14581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterLeft_get() {
14582   void * jresult ;
14583   Dali::Vector3 *result = 0 ;
14584
14585   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_LEFT;
14586   jresult = (void *)result;
14587   return jresult;
14588 }
14589
14590
14591 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenter_get() {
14592   void * jresult ;
14593   Dali::Vector3 *result = 0 ;
14594
14595   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER;
14596   jresult = (void *)result;
14597   return jresult;
14598 }
14599
14600
14601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterRight_get() {
14602   void * jresult ;
14603   Dali::Vector3 *result = 0 ;
14604
14605   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_RIGHT;
14606   jresult = (void *)result;
14607   return jresult;
14608 }
14609
14610
14611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomLeft_get() {
14612   void * jresult ;
14613   Dali::Vector3 *result = 0 ;
14614
14615   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_LEFT;
14616   jresult = (void *)result;
14617   return jresult;
14618 }
14619
14620
14621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomCenter_get() {
14622   void * jresult ;
14623   Dali::Vector3 *result = 0 ;
14624
14625   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_CENTER;
14626   jresult = (void *)result;
14627   return jresult;
14628 }
14629
14630
14631 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomRight_get() {
14632   void * jresult ;
14633   Dali::Vector3 *result = 0 ;
14634
14635   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_RIGHT;
14636   jresult = (void *)result;
14637   return jresult;
14638 }
14639
14640
14641 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointTop_get() {
14642   float jresult ;
14643   float result;
14644
14645   result = (float)(float)Dali::AnchorPoint::TOP;
14646   jresult = result;
14647   return jresult;
14648 }
14649
14650
14651 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointBottom_get() {
14652   float jresult ;
14653   float result;
14654
14655   result = (float)(float)Dali::AnchorPoint::BOTTOM;
14656   jresult = result;
14657   return jresult;
14658 }
14659
14660
14661 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointLeft_get() {
14662   float jresult ;
14663   float result;
14664
14665   result = (float)(float)Dali::AnchorPoint::LEFT;
14666   jresult = result;
14667   return jresult;
14668 }
14669
14670
14671 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointRight_get() {
14672   float jresult ;
14673   float result;
14674
14675   result = (float)(float)Dali::AnchorPoint::RIGHT;
14676   jresult = result;
14677   return jresult;
14678 }
14679
14680
14681 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointMiddle_get() {
14682   float jresult ;
14683   float result;
14684
14685   result = (float)(float)Dali::AnchorPoint::MIDDLE;
14686   jresult = result;
14687   return jresult;
14688 }
14689
14690
14691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopLeft_get() {
14692   void * jresult ;
14693   Dali::Vector3 *result = 0 ;
14694
14695   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_LEFT;
14696   jresult = (void *)result;
14697   return jresult;
14698 }
14699
14700
14701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopCenter_get() {
14702   void * jresult ;
14703   Dali::Vector3 *result = 0 ;
14704
14705   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_CENTER;
14706   jresult = (void *)result;
14707   return jresult;
14708 }
14709
14710
14711 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopRight_get() {
14712   void * jresult ;
14713   Dali::Vector3 *result = 0 ;
14714
14715   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_RIGHT;
14716   jresult = (void *)result;
14717   return jresult;
14718 }
14719
14720
14721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterLeft_get() {
14722   void * jresult ;
14723   Dali::Vector3 *result = 0 ;
14724
14725   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_LEFT;
14726   jresult = (void *)result;
14727   return jresult;
14728 }
14729
14730
14731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenter_get() {
14732   void * jresult ;
14733   Dali::Vector3 *result = 0 ;
14734
14735   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER;
14736   jresult = (void *)result;
14737   return jresult;
14738 }
14739
14740
14741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterRight_get() {
14742   void * jresult ;
14743   Dali::Vector3 *result = 0 ;
14744
14745   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_RIGHT;
14746   jresult = (void *)result;
14747   return jresult;
14748 }
14749
14750
14751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomLeft_get() {
14752   void * jresult ;
14753   Dali::Vector3 *result = 0 ;
14754
14755   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_LEFT;
14756   jresult = (void *)result;
14757   return jresult;
14758 }
14759
14760
14761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomCenter_get() {
14762   void * jresult ;
14763   Dali::Vector3 *result = 0 ;
14764
14765   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_CENTER;
14766   jresult = (void *)result;
14767   return jresult;
14768 }
14769
14770
14771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomRight_get() {
14772   void * jresult ;
14773   Dali::Vector3 *result = 0 ;
14774
14775   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_RIGHT;
14776   jresult = (void *)result;
14777   return jresult;
14778 }
14779
14780
14781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLACK_get() {
14782   void * jresult ;
14783   Dali::Vector4 *result = 0 ;
14784
14785   result = (Dali::Vector4 *)&Dali::Color::BLACK;
14786   jresult = (void *)result;
14787   return jresult;
14788 }
14789
14790
14791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WHITE_get() {
14792   void * jresult ;
14793   Dali::Vector4 *result = 0 ;
14794
14795   result = (Dali::Vector4 *)&Dali::Color::WHITE;
14796   jresult = (void *)result;
14797   return jresult;
14798 }
14799
14800
14801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RED_get() {
14802   void * jresult ;
14803   Dali::Vector4 *result = 0 ;
14804
14805   result = (Dali::Vector4 *)&Dali::Color::RED;
14806   jresult = (void *)result;
14807   return jresult;
14808 }
14809
14810
14811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GREEN_get() {
14812   void * jresult ;
14813   Dali::Vector4 *result = 0 ;
14814
14815   result = (Dali::Vector4 *)&Dali::Color::GREEN;
14816   jresult = (void *)result;
14817   return jresult;
14818 }
14819
14820
14821 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLUE_get() {
14822   void * jresult ;
14823   Dali::Vector4 *result = 0 ;
14824
14825   result = (Dali::Vector4 *)&Dali::Color::BLUE;
14826   jresult = (void *)result;
14827   return jresult;
14828 }
14829
14830
14831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_YELLOW_get() {
14832   void * jresult ;
14833   Dali::Vector4 *result = 0 ;
14834
14835   result = (Dali::Vector4 *)&Dali::Color::YELLOW;
14836   jresult = (void *)result;
14837   return jresult;
14838 }
14839
14840
14841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MAGENTA_get() {
14842   void * jresult ;
14843   Dali::Vector4 *result = 0 ;
14844
14845   result = (Dali::Vector4 *)&Dali::Color::MAGENTA;
14846   jresult = (void *)result;
14847   return jresult;
14848 }
14849
14850
14851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CYAN_get() {
14852   void * jresult ;
14853   Dali::Vector4 *result = 0 ;
14854
14855   result = (Dali::Vector4 *)&Dali::Color::CYAN;
14856   jresult = (void *)result;
14857   return jresult;
14858 }
14859
14860
14861 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TRANSPARENT_get() {
14862   void * jresult ;
14863   Dali::Vector4 *result = 0 ;
14864
14865   result = (Dali::Vector4 *)&Dali::Color::TRANSPARENT;
14866   jresult = (void *)result;
14867   return jresult;
14868 }
14869
14870
14871 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_0_get() {
14872   float jresult ;
14873   float result;
14874
14875   result = (float)(float)Dali::Math::MACHINE_EPSILON_0;
14876   jresult = result;
14877   return jresult;
14878 }
14879
14880
14881 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1_get() {
14882   float jresult ;
14883   float result;
14884
14885   result = (float)(float)Dali::Math::MACHINE_EPSILON_1;
14886   jresult = result;
14887   return jresult;
14888 }
14889
14890
14891 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10_get() {
14892   float jresult ;
14893   float result;
14894
14895   result = (float)(float)Dali::Math::MACHINE_EPSILON_10;
14896   jresult = result;
14897   return jresult;
14898 }
14899
14900
14901 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_100_get() {
14902   float jresult ;
14903   float result;
14904
14905   result = (float)(float)Dali::Math::MACHINE_EPSILON_100;
14906   jresult = result;
14907   return jresult;
14908 }
14909
14910
14911 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1000_get() {
14912   float jresult ;
14913   float result;
14914
14915   result = (float)(float)Dali::Math::MACHINE_EPSILON_1000;
14916   jresult = result;
14917   return jresult;
14918 }
14919
14920
14921 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10000_get() {
14922   float jresult ;
14923   float result;
14924
14925   result = (float)(float)Dali::Math::MACHINE_EPSILON_10000;
14926   jresult = result;
14927   return jresult;
14928 }
14929
14930
14931 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_get() {
14932   float jresult ;
14933   float result;
14934
14935   result = (float)(float)Dali::Math::PI;
14936   jresult = result;
14937   return jresult;
14938 }
14939
14940
14941 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_2_get() {
14942   float jresult ;
14943   float result;
14944
14945   result = (float)(float)Dali::Math::PI_2;
14946   jresult = result;
14947   return jresult;
14948 }
14949
14950
14951 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_4_get() {
14952   float jresult ;
14953   float result;
14954
14955   result = (float)(float)Dali::Math::PI_4;
14956   jresult = result;
14957   return jresult;
14958 }
14959
14960
14961 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_OVER_180_get() {
14962   float jresult ;
14963   float result;
14964
14965   result = (float)(float)Dali::Math::PI_OVER_180;
14966   jresult = result;
14967   return jresult;
14968 }
14969
14970
14971 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ONE80_OVER_PI_get() {
14972   float jresult ;
14973   float result;
14974
14975   result = (float)(float)Dali::Math::ONE80_OVER_PI;
14976   jresult = result;
14977   return jresult;
14978 }
14979
14980
14981 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResizePolicyDefault_get() {
14982   int jresult ;
14983   Dali::ResizePolicy::Type result;
14984
14985   result = (Dali::ResizePolicy::Type)(Dali::ResizePolicy::Type)Dali::ResizePolicy::DEFAULT;
14986   jresult = (int)result;
14987   return jresult;
14988 }
14989
14990
14991 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Count(void * jarg1) {
14992   unsigned long jresult ;
14993   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
14994   Dali::VectorBase::SizeType result;
14995
14996   arg1 = (Dali::VectorBase *)jarg1;
14997   {
14998     try {
14999       result = ((Dali::VectorBase const *)arg1)->Count();
15000     } CALL_CATCH_EXCEPTION(0);
15001   }
15002
15003   jresult = (unsigned long)result;
15004   return jresult;
15005 }
15006
15007
15008 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Size(void * jarg1) {
15009   unsigned long jresult ;
15010   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
15011   Dali::VectorBase::SizeType result;
15012
15013   arg1 = (Dali::VectorBase *)jarg1;
15014   {
15015     try {
15016       result = ((Dali::VectorBase const *)arg1)->Size();
15017     } CALL_CATCH_EXCEPTION(0);
15018   }
15019
15020   jresult = (unsigned long)result;
15021   return jresult;
15022 }
15023
15024
15025 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VectorBase_Empty(void * jarg1) {
15026   unsigned int jresult ;
15027   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
15028   bool result;
15029
15030   arg1 = (Dali::VectorBase *)jarg1;
15031   {
15032     try {
15033       result = (bool)((Dali::VectorBase const *)arg1)->Empty();
15034     } CALL_CATCH_EXCEPTION(0);
15035   }
15036
15037   jresult = result;
15038   return jresult;
15039 }
15040
15041
15042 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Capacity(void * jarg1) {
15043   unsigned long jresult ;
15044   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
15045   Dali::VectorBase::SizeType result;
15046
15047   arg1 = (Dali::VectorBase *)jarg1;
15048   {
15049     try {
15050       result = ((Dali::VectorBase const *)arg1)->Capacity();
15051     } CALL_CATCH_EXCEPTION(0);
15052   }
15053
15054   jresult = (unsigned long)result;
15055   return jresult;
15056 }
15057
15058
15059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBase_Release(void * jarg1) {
15060   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
15061
15062   arg1 = (Dali::VectorBase *)jarg1;
15063   {
15064     try {
15065       (arg1)->Release();
15066     } CALL_CATCH_EXCEPTION();
15067   }
15068
15069 }
15070
15071
15072 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FIRST_VALID_PIXEL_FORMAT_get() {
15073   int jresult ;
15074   Dali::Pixel::Format result;
15075
15076   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::FIRST_VALID_PIXEL_FORMAT;
15077   jresult = (int)result;
15078   return jresult;
15079 }
15080
15081
15082 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LAST_VALID_PIXEL_FORMAT_get() {
15083   int jresult ;
15084   Dali::Pixel::Format result;
15085
15086   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::LAST_VALID_PIXEL_FORMAT;
15087   jresult = (int)result;
15088   return jresult;
15089 }
15090
15091
15092 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_HasAlpha(int jarg1) {
15093   unsigned int jresult ;
15094   Dali::Pixel::Format arg1 ;
15095   bool result;
15096
15097   arg1 = (Dali::Pixel::Format)jarg1;
15098   {
15099     try {
15100       result = (bool)Dali::Pixel::HasAlpha(arg1);
15101     } CALL_CATCH_EXCEPTION(0);
15102   }
15103
15104   jresult = result;
15105   return jresult;
15106 }
15107
15108
15109 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetBytesPerPixel(int jarg1) {
15110   unsigned int jresult ;
15111   Dali::Pixel::Format arg1 ;
15112   unsigned int result;
15113
15114   arg1 = (Dali::Pixel::Format)jarg1;
15115   {
15116     try {
15117       result = (unsigned int)Dali::Pixel::GetBytesPerPixel(arg1);
15118     } CALL_CATCH_EXCEPTION(0);
15119   }
15120
15121   jresult = result;
15122   return jresult;
15123 }
15124
15125
15126 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GetAlphaOffsetAndMask(int jarg1, void * jarg2, void * jarg3) {
15127   Dali::Pixel::Format arg1 ;
15128   int *arg2 = 0 ;
15129   int *arg3 = 0 ;
15130
15131   arg1 = (Dali::Pixel::Format)jarg1;
15132   arg2 = (int *)jarg2;
15133   if (!arg2) {
15134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
15135     return ;
15136   }
15137   arg3 = (int *)jarg3;
15138   if (!arg3) {
15139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
15140     return ;
15141   }
15142   {
15143     try {
15144       Dali::Pixel::GetAlphaOffsetAndMask(arg1,*arg2,*arg3);
15145     } CALL_CATCH_EXCEPTION();
15146   }
15147
15148 }
15149
15150
15151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_New(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5, int jarg6) {
15152   void * jresult ;
15153   unsigned char *arg1 = (unsigned char *) 0 ;
15154   unsigned int arg2 ;
15155   unsigned int arg3 ;
15156   unsigned int arg4 ;
15157   Dali::Pixel::Format arg5 ;
15158   Dali::PixelData::ReleaseFunction arg6 ;
15159   Dali::PixelData result;
15160
15161   arg1 = jarg1;
15162   arg2 = (unsigned int)jarg2;
15163   arg3 = (unsigned int)jarg3;
15164   arg4 = (unsigned int)jarg4;
15165   arg5 = (Dali::Pixel::Format)jarg5;
15166   arg6 = (Dali::PixelData::ReleaseFunction)jarg6;
15167   {
15168     try {
15169       auto pixelBuffer = new unsigned char[jarg2];
15170       memcpy( pixelBuffer, arg1, arg2);
15171       result = Dali::PixelData::New(pixelBuffer,arg2,arg3,arg4,arg5,arg6);
15172     } CALL_CATCH_EXCEPTION(0);
15173   }
15174
15175   jresult = new Dali::PixelData((const Dali::PixelData &)result);
15176
15177
15178   return jresult;
15179 }
15180
15181
15182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_0() {
15183   void * jresult ;
15184   Dali::PixelData *result = 0 ;
15185
15186   {
15187     try {
15188       result = (Dali::PixelData *)new Dali::PixelData();
15189     } CALL_CATCH_EXCEPTION(0);
15190   }
15191
15192   jresult = (void *)result;
15193   return jresult;
15194 }
15195
15196
15197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelData(void * jarg1) {
15198   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
15199
15200   arg1 = (Dali::PixelData *)jarg1;
15201   {
15202     try {
15203       delete arg1;
15204     } CALL_CATCH_EXCEPTION();
15205   }
15206
15207 }
15208
15209
15210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_1(void * jarg1) {
15211   void * jresult ;
15212   Dali::PixelData *arg1 = 0 ;
15213   Dali::PixelData *result = 0 ;
15214
15215   arg1 = (Dali::PixelData *)jarg1;
15216   if (!arg1) {
15217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
15218     return 0;
15219   }
15220   {
15221     try {
15222       result = (Dali::PixelData *)new Dali::PixelData((Dali::PixelData const &)*arg1);
15223     } CALL_CATCH_EXCEPTION(0);
15224   }
15225
15226   jresult = (void *)result;
15227   return jresult;
15228 }
15229
15230
15231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_Assign(void * jarg1, void * jarg2) {
15232   void * jresult ;
15233   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
15234   Dali::PixelData *arg2 = 0 ;
15235   Dali::PixelData *result = 0 ;
15236
15237   arg1 = (Dali::PixelData *)jarg1;
15238   arg2 = (Dali::PixelData *)jarg2;
15239   if (!arg2) {
15240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
15241     return 0;
15242   }
15243   {
15244     try {
15245       result = (Dali::PixelData *) &(arg1)->operator =((Dali::PixelData const &)*arg2);
15246     } CALL_CATCH_EXCEPTION(0);
15247   }
15248
15249   jresult = (void *)result;
15250   return jresult;
15251 }
15252
15253
15254 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetWidth(void * jarg1) {
15255   unsigned int jresult ;
15256   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
15257   unsigned int result;
15258
15259   arg1 = (Dali::PixelData *)jarg1;
15260   {
15261     try {
15262       result = (unsigned int)((Dali::PixelData const *)arg1)->GetWidth();
15263     } CALL_CATCH_EXCEPTION(0);
15264   }
15265
15266   jresult = result;
15267   return jresult;
15268 }
15269
15270
15271 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetHeight(void * jarg1) {
15272   unsigned int jresult ;
15273   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
15274   unsigned int result;
15275
15276   arg1 = (Dali::PixelData *)jarg1;
15277   {
15278     try {
15279       result = (unsigned int)((Dali::PixelData const *)arg1)->GetHeight();
15280     } CALL_CATCH_EXCEPTION(0);
15281   }
15282
15283   jresult = result;
15284   return jresult;
15285 }
15286
15287
15288 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelData_GetPixelFormat(void * jarg1) {
15289   int jresult ;
15290   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
15291   Dali::Pixel::Format result;
15292
15293   arg1 = (Dali::PixelData *)jarg1;
15294   {
15295     try {
15296       result = (Dali::Pixel::Format)((Dali::PixelData const *)arg1)->GetPixelFormat();
15297     } CALL_CATCH_EXCEPTION(0);
15298   }
15299
15300   jresult = (int)result;
15301   return jresult;
15302 }
15303
15304
15305 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_X_get() {
15306   unsigned int jresult ;
15307   unsigned int result;
15308
15309   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_X;
15310   jresult = result;
15311   return jresult;
15312 }
15313
15314
15315 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_X_get() {
15316   unsigned int jresult ;
15317   unsigned int result;
15318
15319   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_X;
15320   jresult = result;
15321   return jresult;
15322 }
15323
15324
15325 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Y_get() {
15326   unsigned int jresult ;
15327   unsigned int result;
15328
15329   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Y;
15330   jresult = result;
15331   return jresult;
15332 }
15333
15334
15335 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Y_get() {
15336   unsigned int jresult ;
15337   unsigned int result;
15338
15339   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Y;
15340   jresult = result;
15341   return jresult;
15342 }
15343
15344
15345 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Z_get() {
15346   unsigned int jresult ;
15347   unsigned int result;
15348
15349   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Z;
15350   jresult = result;
15351   return jresult;
15352 }
15353
15354
15355 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Z_get() {
15356   unsigned int jresult ;
15357   unsigned int result;
15358
15359   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Z;
15360   jresult = result;
15361   return jresult;
15362 }
15363
15364
15365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_0(int jarg1, int jarg2, unsigned int jarg3, unsigned int jarg4) {
15366   void * jresult ;
15367   Dali::TextureType::Type arg1 ;
15368   Dali::Pixel::Format arg2 ;
15369   unsigned int arg3 ;
15370   unsigned int arg4 ;
15371   Dali::Texture result;
15372
15373   arg1 = (Dali::TextureType::Type)jarg1;
15374   arg2 = (Dali::Pixel::Format)jarg2;
15375   arg3 = (unsigned int)jarg3;
15376   arg4 = (unsigned int)jarg4;
15377   {
15378     try {
15379       result = Dali::Texture::New(arg1,arg2,arg3,arg4);
15380     } CALL_CATCH_EXCEPTION(0);
15381   }
15382
15383   jresult = new Dali::Texture((const Dali::Texture &)result);
15384   return jresult;
15385 }
15386
15387
15388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_1(void * jarg1) {
15389   void * jresult ;
15390   NativeImageInterface *arg1 = 0 ;
15391   Dali::Texture result;
15392
15393   arg1 = (NativeImageInterface *)jarg1;
15394   if (!arg1) {
15395     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
15396     return 0;
15397   }
15398   {
15399     try {
15400       result = Dali::Texture::New(*arg1);
15401     } CALL_CATCH_EXCEPTION(0);
15402   }
15403
15404   jresult = new Dali::Texture((const Dali::Texture &)result);
15405   return jresult;
15406 }
15407
15408 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_0() {
15409   void * jresult ;
15410   Dali::Texture *result = 0 ;
15411
15412   {
15413     try {
15414       result = (Dali::Texture *)new Dali::Texture();
15415     } CALL_CATCH_EXCEPTION(0);
15416   }
15417
15418   jresult = (void *)result;
15419   return jresult;
15420 }
15421
15422
15423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Texture(void * jarg1) {
15424   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
15425
15426   arg1 = (Dali::Texture *)jarg1;
15427   {
15428     try {
15429       delete arg1;
15430     } CALL_CATCH_EXCEPTION();
15431   }
15432
15433 }
15434
15435
15436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_1(void * jarg1) {
15437   void * jresult ;
15438   Dali::Texture *arg1 = 0 ;
15439   Dali::Texture *result = 0 ;
15440
15441   arg1 = (Dali::Texture *)jarg1;
15442   if (!arg1) {
15443     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
15444     return 0;
15445   }
15446   {
15447     try {
15448       result = (Dali::Texture *)new Dali::Texture((Dali::Texture const &)*arg1);
15449     } CALL_CATCH_EXCEPTION(0);
15450   }
15451
15452   jresult = (void *)result;
15453   return jresult;
15454 }
15455
15456
15457 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_DownCast(void * jarg1) {
15458   void * jresult ;
15459   Dali::BaseHandle arg1 ;
15460   Dali::BaseHandle *argp1 ;
15461   Dali::Texture result;
15462
15463   argp1 = (Dali::BaseHandle *)jarg1;
15464   if (!argp1) {
15465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
15466     return 0;
15467   }
15468   arg1 = *argp1;
15469   {
15470     try {
15471       result = Dali::Texture::DownCast(arg1);
15472     } CALL_CATCH_EXCEPTION(0);
15473   }
15474
15475   jresult = new Dali::Texture((const Dali::Texture &)result);
15476   return jresult;
15477 }
15478
15479
15480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_Assign(void * jarg1, void * jarg2) {
15481   void * jresult ;
15482   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
15483   Dali::Texture *arg2 = 0 ;
15484   Dali::Texture *result = 0 ;
15485
15486   arg1 = (Dali::Texture *)jarg1;
15487   arg2 = (Dali::Texture *)jarg2;
15488   if (!arg2) {
15489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
15490     return 0;
15491   }
15492   {
15493     try {
15494       result = (Dali::Texture *) &(arg1)->operator =((Dali::Texture const &)*arg2);
15495     } CALL_CATCH_EXCEPTION(0);
15496   }
15497
15498   jresult = (void *)result;
15499   return jresult;
15500 }
15501
15502
15503 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_0(void * jarg1, void * jarg2) {
15504   unsigned int jresult ;
15505   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
15506   Dali::PixelData arg2 ;
15507   Dali::PixelData *argp2 ;
15508   bool result;
15509
15510   arg1 = (Dali::Texture *)jarg1;
15511   argp2 = (Dali::PixelData *)jarg2;
15512   if (!argp2) {
15513     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
15514     return 0;
15515   }
15516   arg2 = *argp2;
15517   {
15518     try {
15519       result = (bool)(arg1)->Upload(arg2);
15520     } CALL_CATCH_EXCEPTION(0);
15521   }
15522
15523   jresult = result;
15524   return jresult;
15525 }
15526
15527
15528 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4, unsigned int jarg5, unsigned int jarg6, unsigned int jarg7, unsigned int jarg8) {
15529   unsigned int jresult ;
15530   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
15531   Dali::PixelData arg2 ;
15532   unsigned int arg3 ;
15533   unsigned int arg4 ;
15534   unsigned int arg5 ;
15535   unsigned int arg6 ;
15536   unsigned int arg7 ;
15537   unsigned int arg8 ;
15538   Dali::PixelData *argp2 ;
15539   bool result;
15540
15541   arg1 = (Dali::Texture *)jarg1;
15542   argp2 = (Dali::PixelData *)jarg2;
15543   if (!argp2) {
15544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
15545     return 0;
15546   }
15547   arg2 = *argp2;
15548   arg3 = (unsigned int)jarg3;
15549   arg4 = (unsigned int)jarg4;
15550   arg5 = (unsigned int)jarg5;
15551   arg6 = (unsigned int)jarg6;
15552   arg7 = (unsigned int)jarg7;
15553   arg8 = (unsigned int)jarg8;
15554   {
15555     try {
15556       result = (bool)(arg1)->Upload(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
15557     } CALL_CATCH_EXCEPTION(0);
15558   }
15559
15560   jresult = result;
15561   return jresult;
15562 }
15563
15564
15565 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Texture_GenerateMipmaps(void * jarg1) {
15566   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
15567
15568   arg1 = (Dali::Texture *)jarg1;
15569   {
15570     try {
15571       (arg1)->GenerateMipmaps();
15572     } CALL_CATCH_EXCEPTION();
15573   }
15574
15575 }
15576
15577
15578 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetWidth(void * jarg1) {
15579   unsigned int jresult ;
15580   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
15581   unsigned int result;
15582
15583   arg1 = (Dali::Texture *)jarg1;
15584   {
15585     try {
15586       result = (unsigned int)((Dali::Texture const *)arg1)->GetWidth();
15587     } CALL_CATCH_EXCEPTION(0);
15588   }
15589
15590   jresult = result;
15591   return jresult;
15592 }
15593
15594
15595 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetHeight(void * jarg1) {
15596   unsigned int jresult ;
15597   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
15598   unsigned int result;
15599
15600   arg1 = (Dali::Texture *)jarg1;
15601   {
15602     try {
15603       result = (unsigned int)((Dali::Texture const *)arg1)->GetHeight();
15604     } CALL_CATCH_EXCEPTION(0);
15605   }
15606
15607   jresult = result;
15608   return jresult;
15609 }
15610
15611
15612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_New() {
15613   void * jresult ;
15614   Dali::Sampler result;
15615
15616   {
15617     try {
15618       result = Dali::Sampler::New();
15619     } CALL_CATCH_EXCEPTION(0);
15620   }
15621
15622   jresult = new Dali::Sampler((const Dali::Sampler &)result);
15623   return jresult;
15624 }
15625
15626
15627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_0() {
15628   void * jresult ;
15629   Dali::Sampler *result = 0 ;
15630
15631   {
15632     try {
15633       result = (Dali::Sampler *)new Dali::Sampler();
15634     } CALL_CATCH_EXCEPTION(0);
15635   }
15636
15637   jresult = (void *)result;
15638   return jresult;
15639 }
15640
15641
15642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Sampler(void * jarg1) {
15643   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
15644
15645   arg1 = (Dali::Sampler *)jarg1;
15646   {
15647     try {
15648       delete arg1;
15649     } CALL_CATCH_EXCEPTION();
15650   }
15651
15652 }
15653
15654
15655 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_1(void * jarg1) {
15656   void * jresult ;
15657   Dali::Sampler *arg1 = 0 ;
15658   Dali::Sampler *result = 0 ;
15659
15660   arg1 = (Dali::Sampler *)jarg1;
15661   if (!arg1) {
15662     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
15663     return 0;
15664   }
15665   {
15666     try {
15667       result = (Dali::Sampler *)new Dali::Sampler((Dali::Sampler const &)*arg1);
15668     } CALL_CATCH_EXCEPTION(0);
15669   }
15670
15671   jresult = (void *)result;
15672   return jresult;
15673 }
15674
15675
15676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_DownCast(void * jarg1) {
15677   void * jresult ;
15678   Dali::BaseHandle arg1 ;
15679   Dali::BaseHandle *argp1 ;
15680   Dali::Sampler result;
15681
15682   argp1 = (Dali::BaseHandle *)jarg1;
15683   if (!argp1) {
15684     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
15685     return 0;
15686   }
15687   arg1 = *argp1;
15688   {
15689     try {
15690       result = Dali::Sampler::DownCast(arg1);
15691     } CALL_CATCH_EXCEPTION(0);
15692   }
15693
15694   jresult = new Dali::Sampler((const Dali::Sampler &)result);
15695   return jresult;
15696 }
15697
15698
15699 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_Assign(void * jarg1, void * jarg2) {
15700   void * jresult ;
15701   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
15702   Dali::Sampler *arg2 = 0 ;
15703   Dali::Sampler *result = 0 ;
15704
15705   arg1 = (Dali::Sampler *)jarg1;
15706   arg2 = (Dali::Sampler *)jarg2;
15707   if (!arg2) {
15708     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
15709     return 0;
15710   }
15711   {
15712     try {
15713       result = (Dali::Sampler *) &(arg1)->operator =((Dali::Sampler const &)*arg2);
15714     } CALL_CATCH_EXCEPTION(0);
15715   }
15716
15717   jresult = (void *)result;
15718   return jresult;
15719 }
15720
15721
15722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetFilterMode(void * jarg1, int jarg2, int jarg3) {
15723   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
15724   Dali::FilterMode::Type arg2 ;
15725   Dali::FilterMode::Type arg3 ;
15726
15727   arg1 = (Dali::Sampler *)jarg1;
15728   arg2 = (Dali::FilterMode::Type)jarg2;
15729   arg3 = (Dali::FilterMode::Type)jarg3;
15730   {
15731     try {
15732       (arg1)->SetFilterMode(arg2,arg3);
15733     } CALL_CATCH_EXCEPTION();
15734   }
15735
15736 }
15737
15738
15739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_0(void * jarg1, int jarg2, int jarg3) {
15740   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
15741   Dali::WrapMode::Type arg2 ;
15742   Dali::WrapMode::Type arg3 ;
15743
15744   arg1 = (Dali::Sampler *)jarg1;
15745   arg2 = (Dali::WrapMode::Type)jarg2;
15746   arg3 = (Dali::WrapMode::Type)jarg3;
15747   {
15748     try {
15749       (arg1)->SetWrapMode(arg2,arg3);
15750     } CALL_CATCH_EXCEPTION();
15751   }
15752
15753 }
15754
15755
15756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_1(void * jarg1, int jarg2, int jarg3, int jarg4) {
15757   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
15758   Dali::WrapMode::Type arg2 ;
15759   Dali::WrapMode::Type arg3 ;
15760   Dali::WrapMode::Type arg4 ;
15761
15762   arg1 = (Dali::Sampler *)jarg1;
15763   arg2 = (Dali::WrapMode::Type)jarg2;
15764   arg3 = (Dali::WrapMode::Type)jarg3;
15765   arg4 = (Dali::WrapMode::Type)jarg4;
15766   {
15767     try {
15768       (arg1)->SetWrapMode(arg2,arg3,arg4);
15769     } CALL_CATCH_EXCEPTION();
15770   }
15771
15772 }
15773
15774
15775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_New() {
15776   void * jresult ;
15777   Dali::TextureSet result;
15778
15779   {
15780     try {
15781       result = Dali::TextureSet::New();
15782     } CALL_CATCH_EXCEPTION(0);
15783   }
15784
15785   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
15786   return jresult;
15787 }
15788
15789
15790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_0() {
15791   void * jresult ;
15792   Dali::TextureSet *result = 0 ;
15793
15794   {
15795     try {
15796       result = (Dali::TextureSet *)new Dali::TextureSet();
15797     } CALL_CATCH_EXCEPTION(0);
15798   }
15799
15800   jresult = (void *)result;
15801   return jresult;
15802 }
15803
15804
15805 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextureSet(void * jarg1) {
15806   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
15807
15808   arg1 = (Dali::TextureSet *)jarg1;
15809   {
15810     try {
15811       delete arg1;
15812     } CALL_CATCH_EXCEPTION();
15813   }
15814
15815 }
15816
15817
15818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_1(void * jarg1) {
15819   void * jresult ;
15820   Dali::TextureSet *arg1 = 0 ;
15821   Dali::TextureSet *result = 0 ;
15822
15823   arg1 = (Dali::TextureSet *)jarg1;
15824   if (!arg1) {
15825     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
15826     return 0;
15827   }
15828   {
15829     try {
15830       result = (Dali::TextureSet *)new Dali::TextureSet((Dali::TextureSet const &)*arg1);
15831     } CALL_CATCH_EXCEPTION(0);
15832   }
15833
15834   jresult = (void *)result;
15835   return jresult;
15836 }
15837
15838
15839 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_DownCast(void * jarg1) {
15840   void * jresult ;
15841   Dali::BaseHandle arg1 ;
15842   Dali::BaseHandle *argp1 ;
15843   Dali::TextureSet result;
15844
15845   argp1 = (Dali::BaseHandle *)jarg1;
15846   if (!argp1) {
15847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
15848     return 0;
15849   }
15850   arg1 = *argp1;
15851   {
15852     try {
15853       result = Dali::TextureSet::DownCast(arg1);
15854     } CALL_CATCH_EXCEPTION(0);
15855   }
15856
15857   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
15858   return jresult;
15859 }
15860
15861
15862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_Assign(void * jarg1, void * jarg2) {
15863   void * jresult ;
15864   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
15865   Dali::TextureSet *arg2 = 0 ;
15866   Dali::TextureSet *result = 0 ;
15867
15868   arg1 = (Dali::TextureSet *)jarg1;
15869   arg2 = (Dali::TextureSet *)jarg2;
15870   if (!arg2) {
15871     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
15872     return 0;
15873   }
15874   {
15875     try {
15876       result = (Dali::TextureSet *) &(arg1)->operator =((Dali::TextureSet const &)*arg2);
15877     } CALL_CATCH_EXCEPTION(0);
15878   }
15879
15880   jresult = (void *)result;
15881   return jresult;
15882 }
15883
15884
15885 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetTexture(void * jarg1, unsigned long jarg2, void * jarg3) {
15886   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
15887   size_t arg2 ;
15888   Dali::Texture arg3 ;
15889   Dali::Texture *argp3 ;
15890
15891   arg1 = (Dali::TextureSet *)jarg1;
15892   arg2 = (size_t)jarg2;
15893   argp3 = (Dali::Texture *)jarg3;
15894   if (!argp3) {
15895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
15896     return ;
15897   }
15898   arg3 = *argp3;
15899   {
15900     try {
15901       (arg1)->SetTexture(arg2,arg3);
15902     } CALL_CATCH_EXCEPTION();
15903   }
15904
15905 }
15906
15907
15908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetTexture(void * jarg1, unsigned long jarg2) {
15909   void * jresult ;
15910   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
15911   size_t arg2 ;
15912   Dali::Texture result;
15913
15914   arg1 = (Dali::TextureSet *)jarg1;
15915   arg2 = (size_t)jarg2;
15916   {
15917     try {
15918       result = ((Dali::TextureSet const *)arg1)->GetTexture(arg2);
15919     } CALL_CATCH_EXCEPTION(0);
15920   }
15921
15922   jresult = new Dali::Texture((const Dali::Texture &)result);
15923   return jresult;
15924 }
15925
15926
15927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetSampler(void * jarg1, unsigned long jarg2, void * jarg3) {
15928   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
15929   size_t arg2 ;
15930   Dali::Sampler arg3 ;
15931   Dali::Sampler *argp3 ;
15932
15933   arg1 = (Dali::TextureSet *)jarg1;
15934   arg2 = (size_t)jarg2;
15935   argp3 = (Dali::Sampler *)jarg3;
15936   if (!argp3) {
15937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Sampler", 0);
15938     return ;
15939   }
15940   arg3 = *argp3;
15941   {
15942     try {
15943       (arg1)->SetSampler(arg2,arg3);
15944     } CALL_CATCH_EXCEPTION();
15945   }
15946
15947 }
15948
15949
15950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetSampler(void * jarg1, unsigned long jarg2) {
15951   void * jresult ;
15952   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
15953   size_t arg2 ;
15954   Dali::Sampler result;
15955
15956   arg1 = (Dali::TextureSet *)jarg1;
15957   arg2 = (size_t)jarg2;
15958   {
15959     try {
15960       result = ((Dali::TextureSet const *)arg1)->GetSampler(arg2);
15961     } CALL_CATCH_EXCEPTION(0);
15962   }
15963
15964   jresult = new Dali::Sampler((const Dali::Sampler &)result);
15965   return jresult;
15966 }
15967
15968
15969 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextureSet_GetTextureCount(void * jarg1) {
15970   unsigned long jresult ;
15971   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
15972   size_t result;
15973
15974   arg1 = (Dali::TextureSet *)jarg1;
15975   {
15976     try {
15977       result = ((Dali::TextureSet const *)arg1)->GetTextureCount();
15978     } CALL_CATCH_EXCEPTION(0);
15979   }
15980
15981   jresult = (unsigned long)result;
15982   return jresult;
15983 }
15984
15985
15986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VertexBuffer_New(void * jarg1) {
15987   void * jresult ;
15988   Dali::Property::Map *arg1 = 0 ;
15989   Dali::VertexBuffer result;
15990
15991   arg1 = (Dali::Property::Map *)jarg1;
15992   if (!arg1) {
15993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
15994     return 0;
15995   }
15996   {
15997     try {
15998       result = Dali::VertexBuffer::New(*arg1);
15999     } CALL_CATCH_EXCEPTION(0);
16000   }
16001
16002   jresult = new Dali::VertexBuffer((const Dali::VertexBuffer &)result);
16003   return jresult;
16004 }
16005
16006
16007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VertexBuffer__SWIG_0() {
16008   void * jresult ;
16009   Dali::VertexBuffer *result = 0 ;
16010
16011   {
16012     try {
16013       result = (Dali::VertexBuffer *)new Dali::VertexBuffer();
16014     } CALL_CATCH_EXCEPTION(0);
16015   }
16016
16017   jresult = (void *)result;
16018   return jresult;
16019 }
16020
16021
16022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VertexBuffer(void * jarg1) {
16023   Dali::VertexBuffer *arg1 = (Dali::VertexBuffer *) 0 ;
16024
16025   arg1 = (Dali::VertexBuffer *)jarg1;
16026   {
16027     try {
16028       delete arg1;
16029     } CALL_CATCH_EXCEPTION();
16030   }
16031
16032 }
16033
16034
16035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VertexBuffer__SWIG_1(void * jarg1) {
16036   void * jresult ;
16037   Dali::VertexBuffer *arg1 = 0 ;
16038   Dali::VertexBuffer *result = 0 ;
16039
16040   arg1 = (Dali::VertexBuffer *)jarg1;
16041   if (!arg1) {
16042     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::VertexBuffer const & type is null", 0);
16043     return 0;
16044   }
16045   {
16046     try {
16047       result = (Dali::VertexBuffer *)new Dali::VertexBuffer((Dali::VertexBuffer const &)*arg1);
16048     } CALL_CATCH_EXCEPTION(0);
16049   }
16050
16051   jresult = (void *)result;
16052   return jresult;
16053 }
16054
16055
16056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VertexBuffer_DownCast(void * jarg1) {
16057   void * jresult ;
16058   Dali::BaseHandle arg1 ;
16059   Dali::BaseHandle *argp1 ;
16060   Dali::VertexBuffer result;
16061
16062   argp1 = (Dali::BaseHandle *)jarg1;
16063   if (!argp1) {
16064     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
16065     return 0;
16066   }
16067   arg1 = *argp1;
16068   {
16069     try {
16070       result = Dali::VertexBuffer::DownCast(arg1);
16071     } CALL_CATCH_EXCEPTION(0);
16072   }
16073
16074   jresult = new Dali::VertexBuffer((const Dali::VertexBuffer &)result);
16075   return jresult;
16076 }
16077
16078
16079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VertexBuffer_Assign(void * jarg1, void * jarg2) {
16080   void * jresult ;
16081   Dali::VertexBuffer *arg1 = (Dali::VertexBuffer *) 0 ;
16082   Dali::VertexBuffer *arg2 = 0 ;
16083   Dali::VertexBuffer *result = 0 ;
16084
16085   arg1 = (Dali::VertexBuffer *)jarg1;
16086   arg2 = (Dali::VertexBuffer *)jarg2;
16087   if (!arg2) {
16088     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::VertexBuffer const & type is null", 0);
16089     return 0;
16090   }
16091   {
16092     try {
16093       result = (Dali::VertexBuffer *) &(arg1)->operator =((Dali::VertexBuffer const &)*arg2);
16094     } CALL_CATCH_EXCEPTION(0);
16095   }
16096
16097   jresult = (void *)result;
16098   return jresult;
16099 }
16100
16101
16102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VertexBuffer_SetData(void * jarg1, void * jarg2, unsigned long jarg3) {
16103   Dali::VertexBuffer *arg1 = (Dali::VertexBuffer *) 0 ;
16104   void *arg2 = (void *) 0 ;
16105   std::size_t arg3 ;
16106
16107   arg1 = (Dali::VertexBuffer *)jarg1;
16108   arg2 = jarg2;
16109   arg3 = (std::size_t)jarg3;
16110   {
16111     try {
16112       (arg1)->SetData((void const *)arg2,arg3);
16113     } CALL_CATCH_EXCEPTION();
16114   }
16115
16116 }
16117
16118
16119 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VertexBuffer_GetSize(void * jarg1) {
16120   unsigned long jresult ;
16121   Dali::VertexBuffer *arg1 = (Dali::VertexBuffer *) 0 ;
16122   std::size_t result;
16123
16124   arg1 = (Dali::VertexBuffer *)jarg1;
16125   {
16126     try {
16127       result = ((Dali::VertexBuffer const *)arg1)->GetSize();
16128     } CALL_CATCH_EXCEPTION(0);
16129   }
16130
16131   jresult = (unsigned long)result;
16132   return jresult;
16133 }
16134
16135
16136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_New() {
16137   void * jresult ;
16138   Dali::Geometry result;
16139
16140   {
16141     try {
16142       result = Dali::Geometry::New();
16143     } CALL_CATCH_EXCEPTION(0);
16144   }
16145
16146   jresult = new Dali::Geometry((const Dali::Geometry &)result);
16147   return jresult;
16148 }
16149
16150
16151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_0() {
16152   void * jresult ;
16153   Dali::Geometry *result = 0 ;
16154
16155   {
16156     try {
16157       result = (Dali::Geometry *)new Dali::Geometry();
16158     } CALL_CATCH_EXCEPTION(0);
16159   }
16160
16161   jresult = (void *)result;
16162   return jresult;
16163 }
16164
16165
16166 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Geometry(void * jarg1) {
16167   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
16168
16169   arg1 = (Dali::Geometry *)jarg1;
16170   {
16171     try {
16172       delete arg1;
16173     } CALL_CATCH_EXCEPTION();
16174   }
16175
16176 }
16177
16178
16179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_1(void * jarg1) {
16180   void * jresult ;
16181   Dali::Geometry *arg1 = 0 ;
16182   Dali::Geometry *result = 0 ;
16183
16184   arg1 = (Dali::Geometry *)jarg1;
16185   if (!arg1) {
16186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
16187     return 0;
16188   }
16189   {
16190     try {
16191       result = (Dali::Geometry *)new Dali::Geometry((Dali::Geometry const &)*arg1);
16192     } CALL_CATCH_EXCEPTION(0);
16193   }
16194
16195   jresult = (void *)result;
16196   return jresult;
16197 }
16198
16199
16200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_DownCast(void * jarg1) {
16201   void * jresult ;
16202   Dali::BaseHandle arg1 ;
16203   Dali::BaseHandle *argp1 ;
16204   Dali::Geometry result;
16205
16206   argp1 = (Dali::BaseHandle *)jarg1;
16207   if (!argp1) {
16208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
16209     return 0;
16210   }
16211   arg1 = *argp1;
16212   {
16213     try {
16214       result = Dali::Geometry::DownCast(arg1);
16215     } CALL_CATCH_EXCEPTION(0);
16216   }
16217
16218   jresult = new Dali::Geometry((const Dali::Geometry &)result);
16219   return jresult;
16220 }
16221
16222
16223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_Assign(void * jarg1, void * jarg2) {
16224   void * jresult ;
16225   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
16226   Dali::Geometry *arg2 = 0 ;
16227   Dali::Geometry *result = 0 ;
16228
16229   arg1 = (Dali::Geometry *)jarg1;
16230   arg2 = (Dali::Geometry *)jarg2;
16231   if (!arg2) {
16232     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
16233     return 0;
16234   }
16235   {
16236     try {
16237       result = (Dali::Geometry *) &(arg1)->operator =((Dali::Geometry const &)*arg2);
16238     } CALL_CATCH_EXCEPTION(0);
16239   }
16240
16241   jresult = (void *)result;
16242   return jresult;
16243 }
16244
16245
16246 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_AddVertexBuffer(void * jarg1, void * jarg2) {
16247   unsigned long jresult ;
16248   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
16249   Dali::VertexBuffer *arg2 = 0 ;
16250   std::size_t result;
16251
16252   arg1 = (Dali::Geometry *)jarg1;
16253   arg2 = (Dali::VertexBuffer *)jarg2;
16254   if (!arg2) {
16255     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::VertexBuffer & type is null", 0);
16256     return 0;
16257   }
16258   {
16259     try {
16260       result = (arg1)->AddVertexBuffer(*arg2);
16261     } CALL_CATCH_EXCEPTION(0);
16262   }
16263
16264   jresult = (unsigned long)result;
16265   return jresult;
16266 }
16267
16268
16269 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_GetNumberOfVertexBuffers(void * jarg1) {
16270   unsigned long jresult ;
16271   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
16272   std::size_t result;
16273
16274   arg1 = (Dali::Geometry *)jarg1;
16275   {
16276     try {
16277       result = ((Dali::Geometry const *)arg1)->GetNumberOfVertexBuffers();
16278     } CALL_CATCH_EXCEPTION(0);
16279   }
16280
16281   jresult = (unsigned long)result;
16282   return jresult;
16283 }
16284
16285
16286 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_RemoveVertexBuffer(void * jarg1, unsigned long jarg2) {
16287   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
16288   std::size_t arg2 ;
16289
16290   arg1 = (Dali::Geometry *)jarg1;
16291   arg2 = (std::size_t)jarg2;
16292   {
16293     try {
16294       (arg1)->RemoveVertexBuffer(arg2);
16295     } CALL_CATCH_EXCEPTION();
16296   }
16297
16298 }
16299
16300
16301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetIndexBuffer(void * jarg1, unsigned short* jarg2, unsigned long jarg3) {
16302   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
16303   unsigned short *arg2 = (unsigned short *) 0 ;
16304   size_t arg3 ;
16305
16306   arg1 = (Dali::Geometry *)jarg1;
16307   arg2 = jarg2;
16308   arg3 = (size_t)jarg3;
16309   {
16310     try {
16311       (arg1)->SetIndexBuffer((unsigned short const *)arg2,arg3);
16312     } CALL_CATCH_EXCEPTION();
16313   }
16314
16315
16316
16317 }
16318
16319
16320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetType(void * jarg1, int jarg2) {
16321   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
16322   Dali::Geometry::Type arg2 ;
16323
16324   arg1 = (Dali::Geometry *)jarg1;
16325   arg2 = (Dali::Geometry::Type)jarg2;
16326   {
16327     try {
16328       (arg1)->SetType(arg2);
16329     } CALL_CATCH_EXCEPTION();
16330   }
16331
16332 }
16333
16334
16335 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Geometry_GetType(void * jarg1) {
16336   int jresult ;
16337   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
16338   Dali::Geometry::Type result;
16339
16340   arg1 = (Dali::Geometry *)jarg1;
16341   {
16342     try {
16343       result = (Dali::Geometry::Type)((Dali::Geometry const *)arg1)->GetType();
16344     } CALL_CATCH_EXCEPTION(0);
16345   }
16346
16347   jresult = (int)result;
16348   return jresult;
16349 }
16350
16351
16352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Hint() {
16353   void * jresult ;
16354   Dali::Shader::Hint *result = 0 ;
16355
16356   {
16357     try {
16358       result = (Dali::Shader::Hint *)new Dali::Shader::Hint();
16359     } CALL_CATCH_EXCEPTION(0);
16360   }
16361
16362   jresult = (void *)result;
16363   return jresult;
16364 }
16365
16366
16367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Hint(void * jarg1) {
16368   Dali::Shader::Hint *arg1 = (Dali::Shader::Hint *) 0 ;
16369
16370   arg1 = (Dali::Shader::Hint *)jarg1;
16371   {
16372     try {
16373       delete arg1;
16374     } CALL_CATCH_EXCEPTION();
16375   }
16376
16377 }
16378
16379
16380 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shader_Property_PROGRAM_get() {
16381   int jresult ;
16382   int result;
16383
16384   result = (int)Dali::Shader::Property::PROGRAM;
16385   jresult = (int)result;
16386   return jresult;
16387 }
16388
16389
16390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Property() {
16391   void * jresult ;
16392   Dali::Shader::Property *result = 0 ;
16393
16394   {
16395     try {
16396       result = (Dali::Shader::Property *)new Dali::Shader::Property();
16397     } CALL_CATCH_EXCEPTION(0);
16398   }
16399
16400   jresult = (void *)result;
16401   return jresult;
16402 }
16403
16404
16405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Property(void * jarg1) {
16406   Dali::Shader::Property *arg1 = (Dali::Shader::Property *) 0 ;
16407
16408   arg1 = (Dali::Shader::Property *)jarg1;
16409   {
16410     try {
16411       delete arg1;
16412     } CALL_CATCH_EXCEPTION();
16413   }
16414
16415 }
16416
16417
16418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_0(char * jarg1, char * jarg2, int jarg3) {
16419   void * jresult ;
16420   std::string *arg1 = 0 ;
16421   std::string *arg2 = 0 ;
16422   Dali::Shader::Hint::Value arg3 ;
16423   Dali::Shader result;
16424
16425   if (!jarg1) {
16426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16427     return 0;
16428   }
16429   std::string arg1_str(jarg1);
16430   arg1 = &arg1_str;
16431   if (!jarg2) {
16432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16433     return 0;
16434   }
16435   std::string arg2_str(jarg2);
16436   arg2 = &arg2_str;
16437   arg3 = (Dali::Shader::Hint::Value)jarg3;
16438   {
16439     try {
16440       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2,arg3);
16441     } CALL_CATCH_EXCEPTION(0);
16442   }
16443
16444   jresult = new Dali::Shader((const Dali::Shader &)result);
16445
16446   //argout typemap for const std::string&
16447
16448
16449   //argout typemap for const std::string&
16450
16451   return jresult;
16452 }
16453
16454
16455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_1(char * jarg1, char * jarg2) {
16456   void * jresult ;
16457   std::string *arg1 = 0 ;
16458   std::string *arg2 = 0 ;
16459   Dali::Shader result;
16460
16461   if (!jarg1) {
16462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16463     return 0;
16464   }
16465   std::string arg1_str(jarg1);
16466   arg1 = &arg1_str;
16467   if (!jarg2) {
16468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16469     return 0;
16470   }
16471   std::string arg2_str(jarg2);
16472   arg2 = &arg2_str;
16473   {
16474     try {
16475       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2);
16476     } CALL_CATCH_EXCEPTION(0);
16477   }
16478
16479   jresult = new Dali::Shader((const Dali::Shader &)result);
16480
16481   //argout typemap for const std::string&
16482
16483
16484   //argout typemap for const std::string&
16485
16486   return jresult;
16487 }
16488
16489
16490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_0() {
16491   void * jresult ;
16492   Dali::Shader *result = 0 ;
16493
16494   {
16495     try {
16496       result = (Dali::Shader *)new Dali::Shader();
16497     } CALL_CATCH_EXCEPTION(0);
16498   }
16499
16500   jresult = (void *)result;
16501   return jresult;
16502 }
16503
16504
16505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader(void * jarg1) {
16506   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
16507
16508   arg1 = (Dali::Shader *)jarg1;
16509   {
16510     try {
16511       delete arg1;
16512     } CALL_CATCH_EXCEPTION();
16513   }
16514
16515 }
16516
16517
16518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_1(void * jarg1) {
16519   void * jresult ;
16520   Dali::Shader *arg1 = 0 ;
16521   Dali::Shader *result = 0 ;
16522
16523   arg1 = (Dali::Shader *)jarg1;
16524   if (!arg1) {
16525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
16526     return 0;
16527   }
16528   {
16529     try {
16530       result = (Dali::Shader *)new Dali::Shader((Dali::Shader const &)*arg1);
16531     } CALL_CATCH_EXCEPTION(0);
16532   }
16533
16534   jresult = (void *)result;
16535   return jresult;
16536 }
16537
16538
16539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_DownCast(void * jarg1) {
16540   void * jresult ;
16541   Dali::BaseHandle arg1 ;
16542   Dali::BaseHandle *argp1 ;
16543   Dali::Shader result;
16544
16545   argp1 = (Dali::BaseHandle *)jarg1;
16546   if (!argp1) {
16547     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
16548     return 0;
16549   }
16550   arg1 = *argp1;
16551   {
16552     try {
16553       result = Dali::Shader::DownCast(arg1);
16554     } CALL_CATCH_EXCEPTION(0);
16555   }
16556
16557   jresult = new Dali::Shader((const Dali::Shader &)result);
16558   return jresult;
16559 }
16560
16561
16562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_Assign(void * jarg1, void * jarg2) {
16563   void * jresult ;
16564   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
16565   Dali::Shader *arg2 = 0 ;
16566   Dali::Shader *result = 0 ;
16567
16568   arg1 = (Dali::Shader *)jarg1;
16569   arg2 = (Dali::Shader *)jarg2;
16570   if (!arg2) {
16571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
16572     return 0;
16573   }
16574   {
16575     try {
16576       result = (Dali::Shader *) &(arg1)->operator =((Dali::Shader const &)*arg2);
16577     } CALL_CATCH_EXCEPTION(0);
16578   }
16579
16580   jresult = (void *)result;
16581   return jresult;
16582 }
16583
16584
16585 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_BACKGROUND_EFFECT_get() {
16586   int jresult ;
16587   int result;
16588
16589   result = (int)Dali::Toolkit::DepthIndex::Ranges::BACKGROUND_EFFECT;
16590   jresult = (int)result;
16591   return jresult;
16592 }
16593
16594
16595 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_BACKGROUND_get() {
16596   int jresult ;
16597   int result;
16598
16599   result = (int)Dali::Toolkit::DepthIndex::Ranges::BACKGROUND;
16600   jresult = (int)result;
16601   return jresult;
16602 }
16603
16604
16605 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_CONTENT_get() {
16606   int jresult ;
16607   int result;
16608
16609   result = (int)Dali::Toolkit::DepthIndex::Ranges::CONTENT;
16610   jresult = (int)result;
16611   return jresult;
16612 }
16613
16614
16615 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_DECORATION_get() {
16616   int jresult ;
16617   int result;
16618
16619   result = (int)Dali::Toolkit::DepthIndex::Ranges::DECORATION;
16620   jresult = (int)result;
16621   return jresult;
16622 }
16623
16624
16625 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_FOREGROUND_EFFECT_get() {
16626   int jresult ;
16627   int result;
16628
16629   result = (int)Dali::Toolkit::DepthIndex::FOREGROUND_EFFECT;
16630   jresult = (int)result;
16631   return jresult;
16632 }
16633
16634
16635 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_INDEX_get() {
16636   int jresult ;
16637   int result;
16638
16639   result = (int)Dali::Renderer::Property::DEPTH_INDEX;
16640   jresult = (int)result;
16641   return jresult;
16642 }
16643
16644
16645 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_FACE_CULLING_MODE_get() {
16646   int jresult ;
16647   int result;
16648
16649   result = (int)Dali::Renderer::Property::FACE_CULLING_MODE;
16650   jresult = (int)result;
16651   return jresult;
16652 }
16653
16654
16655 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_MODE_get() {
16656   int jresult ;
16657   int result;
16658
16659   result = (int)Dali::Renderer::Property::BLEND_MODE;
16660   jresult = (int)result;
16661   return jresult;
16662 }
16663
16664
16665 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_RGB_get() {
16666   int jresult ;
16667   int result;
16668
16669   result = (int)Dali::Renderer::Property::BLEND_EQUATION_RGB;
16670   jresult = (int)result;
16671   return jresult;
16672 }
16673
16674
16675 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_ALPHA_get() {
16676   int jresult ;
16677   int result;
16678
16679   result = (int)Dali::Renderer::Property::BLEND_EQUATION_ALPHA;
16680   jresult = (int)result;
16681   return jresult;
16682 }
16683
16684
16685 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_RGB_get() {
16686   int jresult ;
16687   int result;
16688
16689   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB;
16690   jresult = (int)result;
16691   return jresult;
16692 }
16693
16694
16695 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_RGB_get() {
16696   int jresult ;
16697   int result;
16698
16699   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB;
16700   jresult = (int)result;
16701   return jresult;
16702 }
16703
16704
16705 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_ALPHA_get() {
16706   int jresult ;
16707   int result;
16708
16709   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA;
16710   jresult = (int)result;
16711   return jresult;
16712 }
16713
16714
16715 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_ALPHA_get() {
16716   int jresult ;
16717   int result;
16718
16719   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA;
16720   jresult = (int)result;
16721   return jresult;
16722 }
16723
16724
16725 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_COLOR_get() {
16726   int jresult ;
16727   int result;
16728
16729   result = (int)Dali::Renderer::Property::BLEND_COLOR;
16730   jresult = (int)result;
16731   return jresult;
16732 }
16733
16734
16735 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_PRE_MULTIPLIED_ALPHA_get() {
16736   int jresult ;
16737   int result;
16738
16739   result = (int)Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA;
16740   jresult = (int)result;
16741   return jresult;
16742 }
16743
16744
16745 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_FIRST_get() {
16746   int jresult ;
16747   int result;
16748
16749   result = (int)Dali::Renderer::Property::INDEX_RANGE_FIRST;
16750   jresult = (int)result;
16751   return jresult;
16752 }
16753
16754
16755 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_COUNT_get() {
16756   int jresult ;
16757   int result;
16758
16759   result = (int)Dali::Renderer::Property::INDEX_RANGE_COUNT;
16760   jresult = (int)result;
16761   return jresult;
16762 }
16763
16764
16765 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_WRITE_MODE_get() {
16766   int jresult ;
16767   int result;
16768
16769   result = (int)Dali::Renderer::Property::DEPTH_WRITE_MODE;
16770   jresult = (int)result;
16771   return jresult;
16772 }
16773
16774
16775 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_FUNCTION_get() {
16776   int jresult ;
16777   int result;
16778
16779   result = (int)Dali::Renderer::Property::DEPTH_FUNCTION;
16780   jresult = (int)result;
16781   return jresult;
16782 }
16783
16784
16785 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_TEST_MODE_get() {
16786   int jresult ;
16787   int result;
16788
16789   result = (int)Dali::Renderer::Property::DEPTH_TEST_MODE;
16790   jresult = (int)result;
16791   return jresult;
16792 }
16793
16794
16795 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_RENDER_MODE_get() {
16796   int jresult ;
16797   int result;
16798
16799   result = (int)Dali::Renderer::Property::RENDER_MODE;
16800   jresult = (int)result;
16801   return jresult;
16802 }
16803
16804
16805 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_get() {
16806   int jresult ;
16807   int result;
16808
16809   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION;
16810   jresult = (int)result;
16811   return jresult;
16812 }
16813
16814
16815 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_MASK_get() {
16816   int jresult ;
16817   int result;
16818
16819   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_MASK;
16820   jresult = (int)result;
16821   return jresult;
16822 }
16823
16824
16825 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_REFERENCE_get() {
16826   int jresult ;
16827   int result;
16828
16829   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE;
16830   jresult = (int)result;
16831   return jresult;
16832 }
16833
16834
16835 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_MASK_get() {
16836   int jresult ;
16837   int result;
16838
16839   result = (int)Dali::Renderer::Property::STENCIL_MASK;
16840   jresult = (int)result;
16841   return jresult;
16842 }
16843
16844
16845 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_FAIL_get() {
16846   int jresult ;
16847   int result;
16848
16849   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL;
16850   jresult = (int)result;
16851   return jresult;
16852 }
16853
16854
16855 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_FAIL_get() {
16856   int jresult ;
16857   int result;
16858
16859   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL;
16860   jresult = (int)result;
16861   return jresult;
16862 }
16863
16864
16865 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_PASS_get() {
16866   int jresult ;
16867   int result;
16868
16869   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS;
16870   jresult = (int)result;
16871   return jresult;
16872 }
16873
16874
16875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer_Property() {
16876   void * jresult ;
16877   Dali::Renderer::Property *result = 0 ;
16878
16879   {
16880     try {
16881       result = (Dali::Renderer::Property *)new Dali::Renderer::Property();
16882     } CALL_CATCH_EXCEPTION(0);
16883   }
16884
16885   jresult = (void *)result;
16886   return jresult;
16887 }
16888
16889
16890 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer_Property(void * jarg1) {
16891   Dali::Renderer::Property *arg1 = (Dali::Renderer::Property *) 0 ;
16892
16893   arg1 = (Dali::Renderer::Property *)jarg1;
16894   {
16895     try {
16896       delete arg1;
16897     } CALL_CATCH_EXCEPTION();
16898   }
16899
16900 }
16901
16902
16903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_New(void * jarg1, void * jarg2) {
16904   void * jresult ;
16905   Dali::Geometry *arg1 = 0 ;
16906   Dali::Shader *arg2 = 0 ;
16907   Dali::Renderer result;
16908
16909   arg1 = (Dali::Geometry *)jarg1;
16910   if (!arg1) {
16911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
16912     return 0;
16913   }
16914   arg2 = (Dali::Shader *)jarg2;
16915   if (!arg2) {
16916     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
16917     return 0;
16918   }
16919   {
16920     try {
16921       result = Dali::Renderer::New(*arg1,*arg2);
16922     } CALL_CATCH_EXCEPTION(0);
16923   }
16924
16925   jresult = new Dali::Renderer((const Dali::Renderer &)result);
16926   return jresult;
16927 }
16928
16929
16930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_0() {
16931   void * jresult ;
16932   Dali::Renderer *result = 0 ;
16933
16934   {
16935     try {
16936       result = (Dali::Renderer *)new Dali::Renderer();
16937     } CALL_CATCH_EXCEPTION(0);
16938   }
16939
16940   jresult = (void *)result;
16941   return jresult;
16942 }
16943
16944
16945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer(void * jarg1) {
16946   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
16947
16948   arg1 = (Dali::Renderer *)jarg1;
16949   {
16950     try {
16951       delete arg1;
16952     } CALL_CATCH_EXCEPTION();
16953   }
16954
16955 }
16956
16957
16958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_1(void * jarg1) {
16959   void * jresult ;
16960   Dali::Renderer *arg1 = 0 ;
16961   Dali::Renderer *result = 0 ;
16962
16963   arg1 = (Dali::Renderer *)jarg1;
16964   if (!arg1) {
16965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
16966     return 0;
16967   }
16968   {
16969     try {
16970       result = (Dali::Renderer *)new Dali::Renderer((Dali::Renderer const &)*arg1);
16971     } CALL_CATCH_EXCEPTION(0);
16972   }
16973
16974   jresult = (void *)result;
16975   return jresult;
16976 }
16977
16978
16979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_DownCast(void * jarg1) {
16980   void * jresult ;
16981   Dali::BaseHandle arg1 ;
16982   Dali::BaseHandle *argp1 ;
16983   Dali::Renderer result;
16984
16985   argp1 = (Dali::BaseHandle *)jarg1;
16986   if (!argp1) {
16987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
16988     return 0;
16989   }
16990   arg1 = *argp1;
16991   {
16992     try {
16993       result = Dali::Renderer::DownCast(arg1);
16994     } CALL_CATCH_EXCEPTION(0);
16995   }
16996
16997   jresult = new Dali::Renderer((const Dali::Renderer &)result);
16998   return jresult;
16999 }
17000
17001
17002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_Assign(void * jarg1, void * jarg2) {
17003   void * jresult ;
17004   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
17005   Dali::Renderer *arg2 = 0 ;
17006   Dali::Renderer *result = 0 ;
17007
17008   arg1 = (Dali::Renderer *)jarg1;
17009   arg2 = (Dali::Renderer *)jarg2;
17010   if (!arg2) {
17011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
17012     return 0;
17013   }
17014   {
17015     try {
17016       result = (Dali::Renderer *) &(arg1)->operator =((Dali::Renderer const &)*arg2);
17017     } CALL_CATCH_EXCEPTION(0);
17018   }
17019
17020   jresult = (void *)result;
17021   return jresult;
17022 }
17023
17024
17025 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetGeometry(void * jarg1, void * jarg2) {
17026   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
17027   Dali::Geometry *arg2 = 0 ;
17028
17029   arg1 = (Dali::Renderer *)jarg1;
17030   arg2 = (Dali::Geometry *)jarg2;
17031   if (!arg2) {
17032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
17033     return ;
17034   }
17035   {
17036     try {
17037       (arg1)->SetGeometry(*arg2);
17038     } CALL_CATCH_EXCEPTION();
17039   }
17040
17041 }
17042
17043
17044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetGeometry(void * jarg1) {
17045   void * jresult ;
17046   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
17047   Dali::Geometry result;
17048
17049   arg1 = (Dali::Renderer *)jarg1;
17050   {
17051     try {
17052       result = ((Dali::Renderer const *)arg1)->GetGeometry();
17053     } CALL_CATCH_EXCEPTION(0);
17054   }
17055
17056   jresult = new Dali::Geometry((const Dali::Geometry &)result);
17057   return jresult;
17058 }
17059
17060
17061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetIndexRange(void * jarg1, int jarg2, int jarg3) {
17062   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
17063   int arg2 ;
17064   int arg3 ;
17065
17066   arg1 = (Dali::Renderer *)jarg1;
17067   arg2 = (int)jarg2;
17068   arg3 = (int)jarg3;
17069   {
17070     try {
17071       (arg1)->SetIndexRange(arg2,arg3);
17072     } CALL_CATCH_EXCEPTION();
17073   }
17074
17075 }
17076
17077
17078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetTextures(void * jarg1, void * jarg2) {
17079   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
17080   Dali::TextureSet *arg2 = 0 ;
17081
17082   arg1 = (Dali::Renderer *)jarg1;
17083   arg2 = (Dali::TextureSet *)jarg2;
17084   if (!arg2) {
17085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet & type is null", 0);
17086     return ;
17087   }
17088   {
17089     try {
17090       (arg1)->SetTextures(*arg2);
17091     } CALL_CATCH_EXCEPTION();
17092   }
17093
17094 }
17095
17096
17097 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetTextures(void * jarg1) {
17098   void * jresult ;
17099   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
17100   Dali::TextureSet result;
17101
17102   arg1 = (Dali::Renderer *)jarg1;
17103   {
17104     try {
17105       result = ((Dali::Renderer const *)arg1)->GetTextures();
17106     } CALL_CATCH_EXCEPTION(0);
17107   }
17108
17109   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
17110   return jresult;
17111 }
17112
17113
17114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetShader(void * jarg1, void * jarg2) {
17115   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
17116   Dali::Shader *arg2 = 0 ;
17117
17118   arg1 = (Dali::Renderer *)jarg1;
17119   arg2 = (Dali::Shader *)jarg2;
17120   if (!arg2) {
17121     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
17122     return ;
17123   }
17124   {
17125     try {
17126       (arg1)->SetShader(*arg2);
17127     } CALL_CATCH_EXCEPTION();
17128   }
17129
17130 }
17131
17132
17133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetShader(void * jarg1) {
17134   void * jresult ;
17135   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
17136   Dali::Shader result;
17137
17138   arg1 = (Dali::Renderer *)jarg1;
17139   {
17140     try {
17141       result = ((Dali::Renderer const *)arg1)->GetShader();
17142     } CALL_CATCH_EXCEPTION(0);
17143   }
17144
17145   jresult = new Dali::Shader((const Dali::Shader &)result);
17146   return jresult;
17147 }
17148
17149
17150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer_Attachment() {
17151   void * jresult ;
17152   Dali::FrameBuffer::Attachment *result = 0 ;
17153
17154   {
17155     try {
17156       result = (Dali::FrameBuffer::Attachment *)new Dali::FrameBuffer::Attachment();
17157     } CALL_CATCH_EXCEPTION(0);
17158   }
17159
17160   jresult = (void *)result;
17161   return jresult;
17162 }
17163
17164
17165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer_Attachment(void * jarg1) {
17166   Dali::FrameBuffer::Attachment *arg1 = (Dali::FrameBuffer::Attachment *) 0 ;
17167
17168   arg1 = (Dali::FrameBuffer::Attachment *)jarg1;
17169   {
17170     try {
17171       delete arg1;
17172     } CALL_CATCH_EXCEPTION();
17173   }
17174
17175 }
17176
17177
17178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_New(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
17179   void * jresult ;
17180   unsigned int arg1 ;
17181   unsigned int arg2 ;
17182   unsigned int arg3 ;
17183   Dali::FrameBuffer result;
17184
17185   arg1 = (unsigned int)jarg1;
17186   arg2 = (unsigned int)jarg2;
17187   arg3 = (unsigned int)jarg3;
17188   {
17189     try {
17190       result = Dali::FrameBuffer::New(arg1,arg2,static_cast<Dali::FrameBuffer::Attachment::Mask>(arg3));
17191     } CALL_CATCH_EXCEPTION(0);
17192   }
17193
17194   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
17195   return jresult;
17196 }
17197
17198
17199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_0() {
17200   void * jresult ;
17201   Dali::FrameBuffer *result = 0 ;
17202
17203   {
17204     try {
17205       result = (Dali::FrameBuffer *)new Dali::FrameBuffer();
17206     } CALL_CATCH_EXCEPTION(0);
17207   }
17208
17209   jresult = (void *)result;
17210   return jresult;
17211 }
17212
17213
17214 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer(void * jarg1) {
17215   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
17216
17217   arg1 = (Dali::FrameBuffer *)jarg1;
17218   {
17219     try {
17220       delete arg1;
17221     } CALL_CATCH_EXCEPTION();
17222   }
17223
17224 }
17225
17226
17227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_1(void * jarg1) {
17228   void * jresult ;
17229   Dali::FrameBuffer *arg1 = 0 ;
17230   Dali::FrameBuffer *result = 0 ;
17231
17232   arg1 = (Dali::FrameBuffer *)jarg1;
17233   if (!arg1) {
17234     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
17235     return 0;
17236   }
17237   {
17238     try {
17239       result = (Dali::FrameBuffer *)new Dali::FrameBuffer((Dali::FrameBuffer const &)*arg1);
17240     } CALL_CATCH_EXCEPTION(0);
17241   }
17242
17243   jresult = (void *)result;
17244   return jresult;
17245 }
17246
17247
17248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_DownCast(void * jarg1) {
17249   void * jresult ;
17250   Dali::BaseHandle arg1 ;
17251   Dali::BaseHandle *argp1 ;
17252   Dali::FrameBuffer result;
17253
17254   argp1 = (Dali::BaseHandle *)jarg1;
17255   if (!argp1) {
17256     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
17257     return 0;
17258   }
17259   arg1 = *argp1;
17260   {
17261     try {
17262       result = Dali::FrameBuffer::DownCast(arg1);
17263     } CALL_CATCH_EXCEPTION(0);
17264   }
17265
17266   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
17267   return jresult;
17268 }
17269
17270
17271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_Assign(void * jarg1, void * jarg2) {
17272   void * jresult ;
17273   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
17274   Dali::FrameBuffer *arg2 = 0 ;
17275   Dali::FrameBuffer *result = 0 ;
17276
17277   arg1 = (Dali::FrameBuffer *)jarg1;
17278   arg2 = (Dali::FrameBuffer *)jarg2;
17279   if (!arg2) {
17280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
17281     return 0;
17282   }
17283   {
17284     try {
17285       result = (Dali::FrameBuffer *) &(arg1)->operator =((Dali::FrameBuffer const &)*arg2);
17286     } CALL_CATCH_EXCEPTION(0);
17287   }
17288
17289   jresult = (void *)result;
17290   return jresult;
17291 }
17292
17293
17294 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_0(void * jarg1, void * jarg2) {
17295   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
17296   Dali::Texture *arg2 = 0 ;
17297
17298   arg1 = (Dali::FrameBuffer *)jarg1;
17299   arg2 = (Dali::Texture *)jarg2;
17300   if (!arg2) {
17301     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
17302     return ;
17303   }
17304   {
17305     try {
17306       (arg1)->AttachColorTexture(*arg2);
17307     } CALL_CATCH_EXCEPTION();
17308   }
17309
17310 }
17311
17312
17313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
17314   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
17315   Dali::Texture *arg2 = 0 ;
17316   unsigned int arg3 ;
17317   unsigned int arg4 ;
17318
17319   arg1 = (Dali::FrameBuffer *)jarg1;
17320   arg2 = (Dali::Texture *)jarg2;
17321   if (!arg2) {
17322     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
17323     return ;
17324   }
17325   arg3 = (unsigned int)jarg3;
17326   arg4 = (unsigned int)jarg4;
17327   {
17328     try {
17329       (arg1)->AttachColorTexture(*arg2,arg3,arg4);
17330     } CALL_CATCH_EXCEPTION();
17331   }
17332
17333 }
17334
17335
17336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_GetColorTexture(void * jarg1) {
17337   void * jresult ;
17338   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
17339   Dali::Texture result;
17340
17341   arg1 = (Dali::FrameBuffer *)jarg1;
17342   {
17343     try {
17344       result = (arg1)->GetColorTexture();
17345     } CALL_CATCH_EXCEPTION(0);
17346   }
17347
17348   jresult = new Dali::Texture((const Dali::Texture &)result);
17349   return jresult;
17350 }
17351
17352
17353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_0() {
17354   void * jresult ;
17355   Dali::RenderTaskList *result = 0 ;
17356
17357   {
17358     try {
17359       result = (Dali::RenderTaskList *)new Dali::RenderTaskList();
17360     } CALL_CATCH_EXCEPTION(0);
17361   }
17362
17363   jresult = (void *)result;
17364   return jresult;
17365 }
17366
17367
17368 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_DownCast(void * jarg1) {
17369   void * jresult ;
17370   Dali::BaseHandle arg1 ;
17371   Dali::BaseHandle *argp1 ;
17372   Dali::RenderTaskList result;
17373
17374   argp1 = (Dali::BaseHandle *)jarg1;
17375   if (!argp1) {
17376     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
17377     return 0;
17378   }
17379   arg1 = *argp1;
17380   {
17381     try {
17382       result = Dali::RenderTaskList::DownCast(arg1);
17383     } CALL_CATCH_EXCEPTION(0);
17384   }
17385
17386   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
17387   return jresult;
17388 }
17389
17390
17391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskList(void * jarg1) {
17392   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
17393
17394   arg1 = (Dali::RenderTaskList *)jarg1;
17395   {
17396     try {
17397       delete arg1;
17398     } CALL_CATCH_EXCEPTION();
17399   }
17400
17401 }
17402
17403
17404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_1(void * jarg1) {
17405   void * jresult ;
17406   Dali::RenderTaskList *arg1 = 0 ;
17407   Dali::RenderTaskList *result = 0 ;
17408
17409   arg1 = (Dali::RenderTaskList *)jarg1;
17410   if (!arg1) {
17411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
17412     return 0;
17413   }
17414   {
17415     try {
17416       result = (Dali::RenderTaskList *)new Dali::RenderTaskList((Dali::RenderTaskList const &)*arg1);
17417     } CALL_CATCH_EXCEPTION(0);
17418   }
17419
17420   jresult = (void *)result;
17421   return jresult;
17422 }
17423
17424
17425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_Assign(void * jarg1, void * jarg2) {
17426   void * jresult ;
17427   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
17428   Dali::RenderTaskList *arg2 = 0 ;
17429   Dali::RenderTaskList *result = 0 ;
17430
17431   arg1 = (Dali::RenderTaskList *)jarg1;
17432   arg2 = (Dali::RenderTaskList *)jarg2;
17433   if (!arg2) {
17434     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
17435     return 0;
17436   }
17437   {
17438     try {
17439       result = (Dali::RenderTaskList *) &(arg1)->operator =((Dali::RenderTaskList const &)*arg2);
17440     } CALL_CATCH_EXCEPTION(0);
17441   }
17442
17443   jresult = (void *)result;
17444   return jresult;
17445 }
17446
17447
17448 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_CreateTask(void * jarg1) {
17449   void * jresult ;
17450   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
17451   Dali::RenderTask result;
17452
17453   arg1 = (Dali::RenderTaskList *)jarg1;
17454   {
17455     try {
17456       result = (arg1)->CreateTask();
17457     } CALL_CATCH_EXCEPTION(0);
17458   }
17459
17460   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
17461   return jresult;
17462 }
17463
17464
17465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTaskList_RemoveTask(void * jarg1, void * jarg2) {
17466   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
17467   Dali::RenderTask arg2 ;
17468   Dali::RenderTask *argp2 ;
17469
17470   arg1 = (Dali::RenderTaskList *)jarg1;
17471   argp2 = (Dali::RenderTask *)jarg2;
17472   if (!argp2) {
17473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RenderTask", 0);
17474     return ;
17475   }
17476   arg2 = *argp2;
17477   {
17478     try {
17479       (arg1)->RemoveTask(arg2);
17480     } CALL_CATCH_EXCEPTION();
17481   }
17482
17483 }
17484
17485
17486 //// ===============================================end part 1 =================
17487
17488 //// ========================= part 2 ===============================
17489
17490 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTaskCount(void * jarg1) {
17491   unsigned int jresult ;
17492   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
17493   unsigned int result;
17494
17495   arg1 = (Dali::RenderTaskList *)jarg1;
17496   {
17497     try {
17498       result = (unsigned int)((Dali::RenderTaskList const *)arg1)->GetTaskCount();
17499     } CALL_CATCH_EXCEPTION(0);
17500   }
17501
17502   jresult = result;
17503   return jresult;
17504 }
17505
17506
17507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTask(void * jarg1, unsigned int jarg2) {
17508   void * jresult ;
17509   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
17510   unsigned int arg2 ;
17511   Dali::RenderTask result;
17512
17513   arg1 = (Dali::RenderTaskList *)jarg1;
17514   arg2 = (unsigned int)jarg2;
17515   {
17516     try {
17517       result = ((Dali::RenderTaskList const *)arg1)->GetTask(arg2);
17518     } CALL_CATCH_EXCEPTION(0);
17519   }
17520
17521   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
17522   return jresult;
17523 }
17524
17525
17526 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_POSITION_get() {
17527   int jresult ;
17528   int result;
17529
17530   result = (int)Dali::RenderTask::Property::VIEWPORT_POSITION;
17531   jresult = (int)result;
17532   return jresult;
17533 }
17534
17535
17536 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_SIZE_get() {
17537   int jresult ;
17538   int result;
17539
17540   result = (int)Dali::RenderTask::Property::VIEWPORT_SIZE;
17541   jresult = (int)result;
17542   return jresult;
17543 }
17544
17545
17546 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_CLEAR_COLOR_get() {
17547   int jresult ;
17548   int result;
17549
17550   result = (int)Dali::RenderTask::Property::CLEAR_COLOR;
17551   jresult = (int)result;
17552   return jresult;
17553 }
17554
17555
17556 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_REQUIRES_SYNC_get() {
17557   int jresult ;
17558   int result;
17559
17560   result = (int)Dali::RenderTask::Property::REQUIRES_SYNC;
17561   jresult = (int)result;
17562   return jresult;
17563 }
17564
17565
17566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask_Property() {
17567   void * jresult ;
17568   Dali::RenderTask::Property *result = 0 ;
17569
17570   {
17571     try {
17572       result = (Dali::RenderTask::Property *)new Dali::RenderTask::Property();
17573     } CALL_CATCH_EXCEPTION(0);
17574   }
17575
17576   jresult = (void *)result;
17577   return jresult;
17578 }
17579
17580
17581 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask_Property(void * jarg1) {
17582   Dali::RenderTask::Property *arg1 = (Dali::RenderTask::Property *) 0 ;
17583
17584   arg1 = (Dali::RenderTask::Property *)jarg1;
17585   {
17586     try {
17587       delete arg1;
17588     } CALL_CATCH_EXCEPTION();
17589   }
17590
17591 }
17592
17593
17594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION_get() {
17595   void * jresult ;
17596   bool (*result)(Dali::Vector2 &) = 0 ;
17597
17598   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION;
17599   jresult = (void *)result;
17600   return jresult;
17601 }
17602
17603
17604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FULLSCREEN_FRAMEBUFFER_FUNCTION_get() {
17605   void * jresult ;
17606   bool (*result)(Dali::Vector2 &) = 0 ;
17607
17608   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION;
17609   jresult = (void *)result;
17610   return jresult;
17611 }
17612
17613
17614 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_EXCLUSIVE_get() {
17615   unsigned int jresult ;
17616   bool result;
17617
17618   result = (bool)(bool)Dali::RenderTask::DEFAULT_EXCLUSIVE;
17619   jresult = result;
17620   return jresult;
17621 }
17622
17623
17624 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_INPUT_ENABLED_get() {
17625   unsigned int jresult ;
17626   bool result;
17627
17628   result = (bool)(bool)Dali::RenderTask::DEFAULT_INPUT_ENABLED;
17629   jresult = result;
17630   return jresult;
17631 }
17632
17633
17634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_COLOR_get() {
17635   void * jresult ;
17636   Dali::Vector4 *result = 0 ;
17637
17638   result = (Dali::Vector4 *)&Dali::RenderTask::DEFAULT_CLEAR_COLOR;
17639   jresult = (void *)result;
17640   return jresult;
17641 }
17642
17643
17644 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_ENABLED_get() {
17645   unsigned int jresult ;
17646   bool result;
17647
17648   result = (bool)(bool)Dali::RenderTask::DEFAULT_CLEAR_ENABLED;
17649   jresult = result;
17650   return jresult;
17651 }
17652
17653
17654 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CULL_MODE_get() {
17655   unsigned int jresult ;
17656   bool result;
17657
17658   result = (bool)(bool)Dali::RenderTask::DEFAULT_CULL_MODE;
17659   jresult = result;
17660   return jresult;
17661 }
17662
17663
17664 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_REFRESH_RATE_get() {
17665   unsigned int jresult ;
17666   unsigned int result;
17667
17668   result = (unsigned int)(unsigned int)Dali::RenderTask::DEFAULT_REFRESH_RATE;
17669   jresult = result;
17670   return jresult;
17671 }
17672
17673
17674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_0() {
17675   void * jresult ;
17676   Dali::RenderTask *result = 0 ;
17677
17678   {
17679     try {
17680       result = (Dali::RenderTask *)new Dali::RenderTask();
17681     } CALL_CATCH_EXCEPTION(0);
17682   }
17683
17684   jresult = (void *)result;
17685   return jresult;
17686 }
17687
17688
17689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DownCast(void * jarg1) {
17690   void * jresult ;
17691   Dali::BaseHandle arg1 ;
17692   Dali::BaseHandle *argp1 ;
17693   Dali::RenderTask result;
17694
17695   argp1 = (Dali::BaseHandle *)jarg1;
17696   if (!argp1) {
17697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
17698     return 0;
17699   }
17700   arg1 = *argp1;
17701   {
17702     try {
17703       result = Dali::RenderTask::DownCast(arg1);
17704     } CALL_CATCH_EXCEPTION(0);
17705   }
17706
17707   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
17708   return jresult;
17709 }
17710
17711
17712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask(void * jarg1) {
17713   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
17714
17715   arg1 = (Dali::RenderTask *)jarg1;
17716   {
17717     try {
17718       delete arg1;
17719     } CALL_CATCH_EXCEPTION();
17720   }
17721
17722 }
17723
17724
17725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_1(void * jarg1) {
17726   void * jresult ;
17727   Dali::RenderTask *arg1 = 0 ;
17728   Dali::RenderTask *result = 0 ;
17729
17730   arg1 = (Dali::RenderTask *)jarg1;
17731   if (!arg1) {
17732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
17733     return 0;
17734   }
17735   {
17736     try {
17737       result = (Dali::RenderTask *)new Dali::RenderTask((Dali::RenderTask const &)*arg1);
17738     } CALL_CATCH_EXCEPTION(0);
17739   }
17740
17741   jresult = (void *)result;
17742   return jresult;
17743 }
17744
17745
17746 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_Assign(void * jarg1, void * jarg2) {
17747   void * jresult ;
17748   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
17749   Dali::RenderTask *arg2 = 0 ;
17750   Dali::RenderTask *result = 0 ;
17751
17752   arg1 = (Dali::RenderTask *)jarg1;
17753   arg2 = (Dali::RenderTask *)jarg2;
17754   if (!arg2) {
17755     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
17756     return 0;
17757   }
17758   {
17759     try {
17760       result = (Dali::RenderTask *) &(arg1)->operator =((Dali::RenderTask const &)*arg2);
17761     } CALL_CATCH_EXCEPTION(0);
17762   }
17763
17764   jresult = (void *)result;
17765   return jresult;
17766 }
17767
17768
17769 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetSourceActor(void * jarg1, void * jarg2) {
17770   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
17771   Dali::Actor arg2 ;
17772   Dali::Actor *argp2 ;
17773
17774   arg1 = (Dali::RenderTask *)jarg1;
17775   argp2 = (Dali::Actor *)jarg2;
17776   if (!argp2) {
17777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
17778     return ;
17779   }
17780   arg2 = *argp2;
17781   {
17782     try {
17783       (arg1)->SetSourceActor(arg2);
17784     } CALL_CATCH_EXCEPTION();
17785   }
17786
17787 }
17788
17789
17790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetSourceActor(void * jarg1) {
17791   void * jresult ;
17792   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
17793   Dali::Actor result;
17794
17795   arg1 = (Dali::RenderTask *)jarg1;
17796   {
17797     try {
17798       result = ((Dali::RenderTask const *)arg1)->GetSourceActor();
17799     } CALL_CATCH_EXCEPTION(0);
17800   }
17801
17802   jresult = new Dali::Actor((const Dali::Actor &)result);
17803   return jresult;
17804 }
17805
17806
17807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetExclusive(void * jarg1, unsigned int jarg2) {
17808   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
17809   bool arg2 ;
17810
17811   arg1 = (Dali::RenderTask *)jarg1;
17812   arg2 = jarg2 ? true : false;
17813   {
17814     try {
17815       (arg1)->SetExclusive(arg2);
17816     } CALL_CATCH_EXCEPTION();
17817   }
17818
17819 }
17820
17821
17822 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_IsExclusive(void * jarg1) {
17823   unsigned int jresult ;
17824   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
17825   bool result;
17826
17827   arg1 = (Dali::RenderTask *)jarg1;
17828   {
17829     try {
17830       result = (bool)((Dali::RenderTask const *)arg1)->IsExclusive();
17831     } CALL_CATCH_EXCEPTION(0);
17832   }
17833
17834   jresult = result;
17835   return jresult;
17836 }
17837
17838
17839 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetInputEnabled(void * jarg1, unsigned int jarg2) {
17840   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
17841   bool arg2 ;
17842
17843   arg1 = (Dali::RenderTask *)jarg1;
17844   arg2 = jarg2 ? true : false;
17845   {
17846     try {
17847       (arg1)->SetInputEnabled(arg2);
17848     } CALL_CATCH_EXCEPTION();
17849   }
17850
17851 }
17852
17853
17854 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetInputEnabled(void * jarg1) {
17855   unsigned int jresult ;
17856   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
17857   bool result;
17858
17859   arg1 = (Dali::RenderTask *)jarg1;
17860   {
17861     try {
17862       result = (bool)((Dali::RenderTask const *)arg1)->GetInputEnabled();
17863     } CALL_CATCH_EXCEPTION(0);
17864   }
17865
17866   jresult = result;
17867   return jresult;
17868 }
17869
17870
17871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCameraActor(void * jarg1, void * jarg2) {
17872   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
17873   Dali::CameraActor arg2 ;
17874   Dali::CameraActor *argp2 ;
17875
17876   arg1 = (Dali::RenderTask *)jarg1;
17877   argp2 = (Dali::CameraActor *)jarg2;
17878   if (!argp2) {
17879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::CameraActor", 0);
17880     return ;
17881   }
17882   arg2 = *argp2;
17883   {
17884     try {
17885       (arg1)->SetCameraActor(arg2);
17886     } CALL_CATCH_EXCEPTION();
17887   }
17888
17889 }
17890
17891
17892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCameraActor(void * jarg1) {
17893   void * jresult ;
17894   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
17895   Dali::CameraActor result;
17896
17897   arg1 = (Dali::RenderTask *)jarg1;
17898   {
17899     try {
17900       result = ((Dali::RenderTask const *)arg1)->GetCameraActor();
17901     } CALL_CATCH_EXCEPTION(0);
17902   }
17903
17904   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
17905   return jresult;
17906 }
17907
17908
17909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetFrameBuffer(void * jarg1, void * jarg2) {
17910   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
17911   Dali::FrameBuffer arg2 ;
17912   Dali::FrameBuffer *argp2 ;
17913
17914   arg1 = (Dali::RenderTask *)jarg1;
17915   argp2 = (Dali::FrameBuffer *)jarg2;
17916   if (!argp2) {
17917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
17918     return ;
17919   }
17920   arg2 = *argp2;
17921   {
17922     try {
17923       (arg1)->SetFrameBuffer(arg2);
17924     } CALL_CATCH_EXCEPTION();
17925   }
17926
17927 }
17928
17929
17930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetFrameBuffer(void * jarg1) {
17931   void * jresult ;
17932   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
17933   Dali::FrameBuffer result;
17934
17935   arg1 = (Dali::RenderTask *)jarg1;
17936   {
17937     try {
17938       result = ((Dali::RenderTask const *)arg1)->GetFrameBuffer();
17939     } CALL_CATCH_EXCEPTION(0);
17940   }
17941
17942   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
17943   return jresult;
17944 }
17945
17946
17947 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferFunction(void * jarg1, void * jarg2) {
17948   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
17949   Dali::RenderTask::ScreenToFrameBufferFunction arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction) 0 ;
17950
17951   arg1 = (Dali::RenderTask *)jarg1;
17952   arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction)jarg2;
17953   {
17954     try {
17955       (arg1)->SetScreenToFrameBufferFunction(arg2);
17956     } CALL_CATCH_EXCEPTION();
17957   }
17958
17959 }
17960
17961
17962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferFunction(void * jarg1) {
17963   void * jresult ;
17964   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
17965   Dali::RenderTask::ScreenToFrameBufferFunction result;
17966
17967   arg1 = (Dali::RenderTask *)jarg1;
17968   {
17969     try {
17970       result = (Dali::RenderTask::ScreenToFrameBufferFunction)((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferFunction();
17971     } CALL_CATCH_EXCEPTION(0);
17972   }
17973
17974   jresult = (void *)result;
17975   return jresult;
17976 }
17977
17978
17979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferMappingActor(void * jarg1, void * jarg2) {
17980   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
17981   Dali::Actor arg2 ;
17982   Dali::Actor *argp2 ;
17983
17984   arg1 = (Dali::RenderTask *)jarg1;
17985   argp2 = (Dali::Actor *)jarg2;
17986   if (!argp2) {
17987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
17988     return ;
17989   }
17990   arg2 = *argp2;
17991   {
17992     try {
17993       (arg1)->SetScreenToFrameBufferMappingActor(arg2);
17994     } CALL_CATCH_EXCEPTION();
17995   }
17996
17997 }
17998
17999
18000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferMappingActor(void * jarg1) {
18001   void * jresult ;
18002   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18003   Dali::Actor result;
18004
18005   arg1 = (Dali::RenderTask *)jarg1;
18006   {
18007     try {
18008       result = ((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferMappingActor();
18009     } CALL_CATCH_EXCEPTION(0);
18010   }
18011
18012   jresult = new Dali::Actor((const Dali::Actor &)result);
18013   return jresult;
18014 }
18015
18016
18017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportPosition(void * jarg1, void * jarg2) {
18018   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18019   Dali::Vector2 arg2 ;
18020   Dali::Vector2 *argp2 ;
18021
18022   arg1 = (Dali::RenderTask *)jarg1;
18023   argp2 = (Dali::Vector2 *)jarg2;
18024   if (!argp2) {
18025     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
18026     return ;
18027   }
18028   arg2 = *argp2;
18029   {
18030     try {
18031       (arg1)->SetViewportPosition(arg2);
18032     } CALL_CATCH_EXCEPTION();
18033   }
18034
18035 }
18036
18037
18038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportPosition(void * jarg1) {
18039   void * jresult ;
18040   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18041   Dali::Vector2 result;
18042
18043   arg1 = (Dali::RenderTask *)jarg1;
18044   {
18045     try {
18046       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportPosition();
18047     } CALL_CATCH_EXCEPTION(0);
18048   }
18049
18050   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
18051   return jresult;
18052 }
18053
18054
18055 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportSize(void * jarg1, void * jarg2) {
18056   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18057   Dali::Vector2 arg2 ;
18058   Dali::Vector2 *argp2 ;
18059
18060   arg1 = (Dali::RenderTask *)jarg1;
18061   argp2 = (Dali::Vector2 *)jarg2;
18062   if (!argp2) {
18063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
18064     return ;
18065   }
18066   arg2 = *argp2;
18067   {
18068     try {
18069       (arg1)->SetViewportSize(arg2);
18070     } CALL_CATCH_EXCEPTION();
18071   }
18072
18073 }
18074
18075
18076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportSize(void * jarg1) {
18077   void * jresult ;
18078   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18079   Dali::Vector2 result;
18080
18081   arg1 = (Dali::RenderTask *)jarg1;
18082   {
18083     try {
18084       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportSize();
18085     } CALL_CATCH_EXCEPTION(0);
18086   }
18087
18088   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
18089   return jresult;
18090 }
18091
18092
18093 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewport(void * jarg1, void * jarg2) {
18094   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18095   Dali::Viewport arg2 ;
18096   Dali::Viewport *argp2 ;
18097
18098   arg1 = (Dali::RenderTask *)jarg1;
18099   argp2 = (Dali::Viewport *)jarg2;
18100   if (!argp2) {
18101     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Viewport", 0);
18102     return ;
18103   }
18104   arg2 = *argp2;
18105   {
18106     try {
18107       (arg1)->SetViewport(arg2);
18108     } CALL_CATCH_EXCEPTION();
18109   }
18110
18111 }
18112
18113
18114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetViewport(void * jarg1) {
18115   void * jresult ;
18116   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18117   Dali::Viewport result;
18118
18119   arg1 = (Dali::RenderTask *)jarg1;
18120   {
18121     try {
18122       result = ((Dali::RenderTask const *)arg1)->GetViewport();
18123     } CALL_CATCH_EXCEPTION(0);
18124   }
18125
18126   jresult = new Dali::Viewport((const Dali::Viewport &)result);
18127   return jresult;
18128 }
18129
18130
18131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearColor(void * jarg1, void * jarg2) {
18132   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18133   Dali::Vector4 *arg2 = 0 ;
18134
18135   arg1 = (Dali::RenderTask *)jarg1;
18136   arg2 = (Dali::Vector4 *)jarg2;
18137   if (!arg2) {
18138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
18139     return ;
18140   }
18141   {
18142     try {
18143       (arg1)->SetClearColor((Dali::Vector4 const &)*arg2);
18144     } CALL_CATCH_EXCEPTION();
18145   }
18146
18147 }
18148
18149
18150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetClearColor(void * jarg1) {
18151   void * jresult ;
18152   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18153   Dali::Vector4 result;
18154
18155   arg1 = (Dali::RenderTask *)jarg1;
18156   {
18157     try {
18158       result = ((Dali::RenderTask const *)arg1)->GetClearColor();
18159     } CALL_CATCH_EXCEPTION(0);
18160   }
18161
18162   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
18163   return jresult;
18164 }
18165
18166
18167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearEnabled(void * jarg1, unsigned int jarg2) {
18168   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18169   bool arg2 ;
18170
18171   arg1 = (Dali::RenderTask *)jarg1;
18172   arg2 = jarg2 ? true : false;
18173   {
18174     try {
18175       (arg1)->SetClearEnabled(arg2);
18176     } CALL_CATCH_EXCEPTION();
18177   }
18178
18179 }
18180
18181
18182 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetClearEnabled(void * jarg1) {
18183   unsigned int jresult ;
18184   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18185   bool result;
18186
18187   arg1 = (Dali::RenderTask *)jarg1;
18188   {
18189     try {
18190       result = (bool)((Dali::RenderTask const *)arg1)->GetClearEnabled();
18191     } CALL_CATCH_EXCEPTION(0);
18192   }
18193
18194   jresult = result;
18195   return jresult;
18196 }
18197
18198
18199 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCullMode(void * jarg1, unsigned int jarg2) {
18200   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18201   bool arg2 ;
18202
18203   arg1 = (Dali::RenderTask *)jarg1;
18204   arg2 = jarg2 ? true : false;
18205   {
18206     try {
18207       (arg1)->SetCullMode(arg2);
18208     } CALL_CATCH_EXCEPTION();
18209   }
18210
18211 }
18212
18213
18214 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetCullMode(void * jarg1) {
18215   unsigned int jresult ;
18216   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18217   bool result;
18218
18219   arg1 = (Dali::RenderTask *)jarg1;
18220   {
18221     try {
18222       result = (bool)((Dali::RenderTask const *)arg1)->GetCullMode();
18223     } CALL_CATCH_EXCEPTION(0);
18224   }
18225
18226   jresult = result;
18227   return jresult;
18228 }
18229
18230
18231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetRefreshRate(void * jarg1, unsigned int jarg2) {
18232   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18233   unsigned int arg2 ;
18234
18235   arg1 = (Dali::RenderTask *)jarg1;
18236   arg2 = (unsigned int)jarg2;
18237   {
18238     try {
18239       (arg1)->SetRefreshRate(arg2);
18240     } CALL_CATCH_EXCEPTION();
18241   }
18242
18243 }
18244
18245
18246 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetRefreshRate(void * jarg1) {
18247   unsigned int jresult ;
18248   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18249   unsigned int result;
18250
18251   arg1 = (Dali::RenderTask *)jarg1;
18252   {
18253     try {
18254       result = (unsigned int)((Dali::RenderTask const *)arg1)->GetRefreshRate();
18255     } CALL_CATCH_EXCEPTION(0);
18256   }
18257
18258   jresult = result;
18259   return jresult;
18260 }
18261
18262
18263 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_WorldToViewport(void * jarg1, void * jarg2, float * jarg3, float * jarg4) {
18264   unsigned int jresult ;
18265   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18266   Dali::Vector3 *arg2 = 0 ;
18267   float *arg3 = 0 ;
18268   float *arg4 = 0 ;
18269   bool result;
18270
18271   arg1 = (Dali::RenderTask *)jarg1;
18272   arg2 = (Dali::Vector3 *)jarg2;
18273   if (!arg2) {
18274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
18275     return 0;
18276   }
18277   arg3 = (float *)jarg3;
18278   arg4 = (float *)jarg4;
18279   {
18280     try {
18281       result = (bool)((Dali::RenderTask const *)arg1)->WorldToViewport((Dali::Vector3 const &)*arg2,*arg3,*arg4);
18282     } CALL_CATCH_EXCEPTION(0);
18283   }
18284
18285   jresult = result;
18286   return jresult;
18287 }
18288
18289
18290 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_ViewportToLocal(void * jarg1, void * jarg2, float jarg3, float jarg4, float * jarg5, float * jarg6) {
18291   unsigned int jresult ;
18292   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18293   Dali::Actor arg2 ;
18294   float arg3 ;
18295   float arg4 ;
18296   float *arg5 = 0 ;
18297   float *arg6 = 0 ;
18298   Dali::Actor *argp2 ;
18299   bool result;
18300
18301   arg1 = (Dali::RenderTask *)jarg1;
18302   argp2 = (Dali::Actor *)jarg2;
18303   if (!argp2) {
18304     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
18305     return 0;
18306   }
18307   arg2 = *argp2;
18308   arg3 = (float)jarg3;
18309   arg4 = (float)jarg4;
18310   arg5 = (float *)jarg5;
18311   arg6 = (float *)jarg6;
18312   {
18313     try {
18314       result = (bool)((Dali::RenderTask const *)arg1)->ViewportToLocal(arg2,arg3,arg4,*arg5,*arg6);
18315     } CALL_CATCH_EXCEPTION(0);
18316   }
18317
18318   jresult = result;
18319   return jresult;
18320 }
18321
18322
18323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FinishedSignal(void * jarg1) {
18324   void * jresult ;
18325   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
18326   Dali::RenderTask::RenderTaskSignalType *result = 0 ;
18327
18328   arg1 = (Dali::RenderTask *)jarg1;
18329   {
18330     try {
18331       result = (Dali::RenderTask::RenderTaskSignalType *) &(arg1)->FinishedSignal();
18332     } CALL_CATCH_EXCEPTION(0);
18333   }
18334
18335   jresult = (void *)result;
18336   return jresult;
18337 }
18338
18339
18340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_0(int jarg1, int jarg2, float jarg3, float jarg4) {
18341   void * jresult ;
18342   int arg1 ;
18343   Dali::PointState::Type arg2 ;
18344   float arg3 ;
18345   float arg4 ;
18346   Dali::TouchPoint *result = 0 ;
18347
18348   arg1 = (int)jarg1;
18349   arg2 = (Dali::PointState::Type)jarg2;
18350   arg3 = (float)jarg3;
18351   arg4 = (float)jarg4;
18352   {
18353     try {
18354       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4);
18355     } CALL_CATCH_EXCEPTION(0);
18356   }
18357
18358   jresult = (void *)result;
18359   return jresult;
18360 }
18361
18362
18363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_1(int jarg1, int jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
18364   void * jresult ;
18365   int arg1 ;
18366   Dali::PointState::Type arg2 ;
18367   float arg3 ;
18368   float arg4 ;
18369   float arg5 ;
18370   float arg6 ;
18371   Dali::TouchPoint *result = 0 ;
18372
18373   arg1 = (int)jarg1;
18374   arg2 = (Dali::PointState::Type)jarg2;
18375   arg3 = (float)jarg3;
18376   arg4 = (float)jarg4;
18377   arg5 = (float)jarg5;
18378   arg6 = (float)jarg6;
18379   {
18380     try {
18381       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4,arg5,arg6);
18382     } CALL_CATCH_EXCEPTION(0);
18383   }
18384
18385   jresult = (void *)result;
18386   return jresult;
18387 }
18388
18389
18390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPoint(void * jarg1) {
18391   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
18392
18393   arg1 = (Dali::TouchPoint *)jarg1;
18394   {
18395     try {
18396       delete arg1;
18397     } CALL_CATCH_EXCEPTION();
18398   }
18399
18400 }
18401
18402
18403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_set(void * jarg1, int jarg2) {
18404   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
18405   int arg2 ;
18406
18407   arg1 = (Dali::TouchPoint *)jarg1;
18408   arg2 = (int)jarg2;
18409   if (arg1) (arg1)->deviceId = arg2;
18410 }
18411
18412
18413 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_get(void * jarg1) {
18414   int jresult ;
18415   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
18416   int result;
18417
18418   arg1 = (Dali::TouchPoint *)jarg1;
18419   result = (int) ((arg1)->deviceId);
18420   jresult = result;
18421   return jresult;
18422 }
18423
18424
18425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_state_set(void * jarg1, int jarg2) {
18426   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
18427   Dali::PointState::Type arg2 ;
18428
18429   arg1 = (Dali::TouchPoint *)jarg1;
18430   arg2 = (Dali::PointState::Type)jarg2;
18431   if (arg1) (arg1)->state = arg2;
18432 }
18433
18434
18435 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_state_get(void * jarg1) {
18436   int jresult ;
18437   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
18438   Dali::PointState::Type result;
18439
18440   arg1 = (Dali::TouchPoint *)jarg1;
18441   result = (Dali::PointState::Type) ((arg1)->state);
18442   jresult = (int)result;
18443   return jresult;
18444 }
18445
18446
18447 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_set(void * jarg1, void * jarg2) {
18448   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
18449   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
18450
18451   arg1 = (Dali::TouchPoint *)jarg1;
18452   arg2 = (Dali::Actor *)jarg2;
18453   if (arg1) (arg1)->hitActor = *arg2;
18454 }
18455
18456
18457 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_get(void * jarg1) {
18458   void * jresult ;
18459   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
18460   Dali::Actor *result = 0 ;
18461
18462   arg1 = (Dali::TouchPoint *)jarg1;
18463   result = (Dali::Actor *)& ((arg1)->hitActor);
18464   jresult = (void *)result;
18465   return jresult;
18466 }
18467
18468
18469 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_local_set(void * jarg1, void * jarg2) {
18470   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
18471   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
18472
18473   arg1 = (Dali::TouchPoint *)jarg1;
18474   arg2 = (Dali::Vector2 *)jarg2;
18475   if (arg1) (arg1)->local = *arg2;
18476 }
18477
18478
18479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_local_get(void * jarg1) {
18480   void * jresult ;
18481   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
18482   Dali::Vector2 *result = 0 ;
18483
18484   arg1 = (Dali::TouchPoint *)jarg1;
18485   result = (Dali::Vector2 *)& ((arg1)->local);
18486   jresult = (void *)result;
18487   return jresult;
18488 }
18489
18490
18491 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_screen_set(void * jarg1, void * jarg2) {
18492   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
18493   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
18494
18495   arg1 = (Dali::TouchPoint *)jarg1;
18496   arg2 = (Dali::Vector2 *)jarg2;
18497   if (arg1) (arg1)->screen = *arg2;
18498 }
18499
18500
18501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_screen_get(void * jarg1) {
18502   void * jresult ;
18503   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
18504   Dali::Vector2 *result = 0 ;
18505
18506   arg1 = (Dali::TouchPoint *)jarg1;
18507   result = (Dali::Vector2 *)& ((arg1)->screen);
18508   jresult = (void *)result;
18509   return jresult;
18510 }
18511
18512
18513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_0() {
18514   void * jresult ;
18515   Dali::TouchEvent *result = 0 ;
18516
18517   {
18518     try {
18519       result = (Dali::TouchEvent *)new Dali::TouchEvent();
18520     } CALL_CATCH_EXCEPTION(0);
18521   }
18522
18523   jresult = (void *)result;
18524   return jresult;
18525 }
18526
18527
18528 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_1(void * jarg1) {
18529   void * jresult ;
18530   Dali::TouchEvent *arg1 = 0 ;
18531   Dali::TouchEvent *result = 0 ;
18532
18533   arg1 = (Dali::TouchEvent *)jarg1;
18534   if (!arg1) {
18535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
18536     return 0;
18537   }
18538   {
18539     try {
18540       result = (Dali::TouchEvent *)new Dali::TouchEvent((Dali::TouchEvent const &)*arg1);
18541     } CALL_CATCH_EXCEPTION(0);
18542   }
18543
18544   jresult = (void *)result;
18545   return jresult;
18546 }
18547
18548
18549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Touch(void * jarg1) {
18550   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
18551
18552   arg1 = (Dali::TouchEvent *)jarg1;
18553   {
18554     try {
18555       delete arg1;
18556     } CALL_CATCH_EXCEPTION();
18557   }
18558
18559 }
18560
18561
18562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_Assign(void * jarg1, void * jarg2) {
18563   void * jresult ;
18564   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
18565   Dali::TouchEvent *arg2 = 0 ;
18566   Dali::TouchEvent *result = 0 ;
18567
18568   arg1 = (Dali::TouchEvent *)jarg1;
18569   arg2 = (Dali::TouchEvent *)jarg2;
18570   if (!arg2) {
18571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
18572     return 0;
18573   }
18574   {
18575     try {
18576       result = (Dali::TouchEvent *) &(arg1)->operator =((Dali::TouchEvent const &)*arg2);
18577     } CALL_CATCH_EXCEPTION(0);
18578   }
18579
18580   jresult = (void *)result;
18581   return jresult;
18582 }
18583
18584
18585 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetTime(void * jarg1) {
18586   unsigned long jresult ;
18587   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
18588   unsigned long result;
18589
18590   arg1 = (Dali::TouchEvent *)jarg1;
18591   {
18592     try {
18593       result = (unsigned long)((Dali::TouchEvent const *)arg1)->GetTime();
18594     } CALL_CATCH_EXCEPTION(0);
18595   }
18596
18597   jresult = (unsigned long)result;
18598   return jresult;
18599 }
18600
18601
18602 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetPointCount(void * jarg1) {
18603   unsigned long jresult ;
18604   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
18605   std::size_t result;
18606
18607   arg1 = (Dali::TouchEvent *)jarg1;
18608   {
18609     try {
18610       result = ((Dali::TouchEvent const *)arg1)->GetPointCount();
18611     } CALL_CATCH_EXCEPTION(0);
18612   }
18613
18614   jresult = (unsigned long)result;
18615   return jresult;
18616 }
18617
18618
18619 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceId(void * jarg1, unsigned long jarg2) {
18620   int jresult ;
18621   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
18622   std::size_t arg2 ;
18623   int32_t result;
18624
18625   arg1 = (Dali::TouchEvent *)jarg1;
18626   arg2 = (std::size_t)jarg2;
18627   {
18628     try {
18629       result = ((Dali::TouchEvent const *)arg1)->GetDeviceId(arg2);
18630     } CALL_CATCH_EXCEPTION(0);
18631   }
18632
18633   jresult = result;
18634   return jresult;
18635 }
18636
18637
18638 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetState(void * jarg1, unsigned long jarg2) {
18639   int jresult ;
18640   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
18641   std::size_t arg2 ;
18642   Dali::PointState::Type result;
18643
18644   arg1 = (Dali::TouchEvent *)jarg1;
18645   arg2 = (std::size_t)jarg2;
18646   {
18647     try {
18648       result = (Dali::PointState::Type)((Dali::TouchEvent const *)arg1)->GetState(arg2);
18649     } CALL_CATCH_EXCEPTION(0);
18650   }
18651
18652   jresult = (int)result;
18653   return jresult;
18654 }
18655
18656
18657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetHitActor(void * jarg1, unsigned long jarg2) {
18658   void * jresult ;
18659   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
18660   std::size_t arg2 ;
18661   Dali::Actor result;
18662
18663   arg1 = (Dali::TouchEvent *)jarg1;
18664   arg2 = (std::size_t)jarg2;
18665   {
18666     try {
18667       result = ((Dali::TouchEvent const *)arg1)->GetHitActor(arg2);
18668     } CALL_CATCH_EXCEPTION(0);
18669   }
18670
18671   jresult = new Dali::Actor((const Dali::Actor &)result);
18672   return jresult;
18673 }
18674
18675
18676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetLocalPosition(void * jarg1, unsigned long jarg2) {
18677   void * jresult ;
18678   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
18679   std::size_t arg2 ;
18680   Dali::Vector2 *result = 0 ;
18681
18682   arg1 = (Dali::TouchEvent *)jarg1;
18683   arg2 = (std::size_t)jarg2;
18684   {
18685     try {
18686       result = (Dali::Vector2 *) &((Dali::TouchEvent const *)arg1)->GetLocalPosition(arg2);
18687     } CALL_CATCH_EXCEPTION(0);
18688   }
18689
18690   jresult = (void *)result;
18691   return jresult;
18692 }
18693
18694
18695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetScreenPosition(void * jarg1, unsigned long jarg2) {
18696   void * jresult ;
18697   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
18698   std::size_t arg2 ;
18699   Dali::Vector2 *result = 0 ;
18700
18701   arg1 = (Dali::TouchEvent *)jarg1;
18702   arg2 = (std::size_t)jarg2;
18703   {
18704     try {
18705       result = (Dali::Vector2 *) &((Dali::TouchEvent const *)arg1)->GetScreenPosition(arg2);
18706     } CALL_CATCH_EXCEPTION(0);
18707   }
18708
18709   jresult = (void *)result;
18710   return jresult;
18711 }
18712
18713
18714 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetRadius(void * jarg1, unsigned long jarg2) {
18715   float jresult ;
18716   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
18717   std::size_t arg2 ;
18718   float result;
18719
18720   arg1 = (Dali::TouchEvent *)jarg1;
18721   arg2 = (std::size_t)jarg2;
18722   {
18723     try {
18724       result = (float)((Dali::TouchEvent const *)arg1)->GetRadius(arg2);
18725     } CALL_CATCH_EXCEPTION(0);
18726   }
18727
18728   jresult = result;
18729   return jresult;
18730 }
18731
18732
18733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetEllipseRadius(void * jarg1, unsigned long jarg2) {
18734   void * jresult ;
18735   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
18736   std::size_t arg2 ;
18737   Dali::Vector2 *result = 0 ;
18738
18739   arg1 = (Dali::TouchEvent *)jarg1;
18740   arg2 = (std::size_t)jarg2;
18741   {
18742     try {
18743       result = (Dali::Vector2 *) &((Dali::TouchEvent const *)arg1)->GetEllipseRadius(arg2);
18744     } CALL_CATCH_EXCEPTION(0);
18745   }
18746
18747   jresult = (void *)result;
18748   return jresult;
18749 }
18750
18751
18752 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetPressure(void * jarg1, unsigned long jarg2) {
18753   float jresult ;
18754   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
18755   std::size_t arg2 ;
18756   float result;
18757
18758   arg1 = (Dali::TouchEvent *)jarg1;
18759   arg2 = (std::size_t)jarg2;
18760   {
18761     try {
18762       result = (float)((Dali::TouchEvent const *)arg1)->GetPressure(arg2);
18763     } CALL_CATCH_EXCEPTION(0);
18764   }
18765
18766   jresult = result;
18767   return jresult;
18768 }
18769
18770
18771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetAngle(void * jarg1, unsigned long jarg2) {
18772   void * jresult ;
18773   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
18774   std::size_t arg2 ;
18775   Dali::Degree result;
18776
18777   arg1 = (Dali::TouchEvent *)jarg1;
18778   arg2 = (std::size_t)jarg2;
18779   {
18780     try {
18781       result = ((Dali::TouchEvent const *)arg1)->GetAngle(arg2);
18782     } CALL_CATCH_EXCEPTION(0);
18783   }
18784
18785   jresult = new Dali::Degree((const Dali::Degree &)result);
18786   return jresult;
18787 }
18788
18789
18790 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetMouseButton(void * jarg1, unsigned long jarg2) {
18791   int jresult ;
18792   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
18793   std::size_t arg2 ;
18794   Dali::MouseButton::Type result;
18795
18796   arg1 = (Dali::TouchEvent *)jarg1;
18797   arg2 = (std::size_t)jarg2;
18798   {
18799     try {
18800       result = ((Dali::TouchEvent const *)arg1)->GetMouseButton(arg2);
18801     } CALL_CATCH_EXCEPTION(0);
18802   }
18803
18804   jresult = static_cast< int >(result);
18805   return jresult;
18806 }
18807
18808
18809 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_0() {
18810   void * jresult ;
18811   Dali::GestureDetector *result = 0 ;
18812
18813   {
18814     try {
18815       result = (Dali::GestureDetector *)new Dali::GestureDetector();
18816     } CALL_CATCH_EXCEPTION(0);
18817   }
18818
18819   jresult = (void *)result;
18820   return jresult;
18821 }
18822
18823
18824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_DownCast(void * jarg1) {
18825   void * jresult ;
18826   Dali::BaseHandle arg1 ;
18827   Dali::BaseHandle *argp1 ;
18828   Dali::GestureDetector result;
18829
18830   argp1 = (Dali::BaseHandle *)jarg1;
18831   if (!argp1) {
18832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
18833     return 0;
18834   }
18835   arg1 = *argp1;
18836   {
18837     try {
18838       result = Dali::GestureDetector::DownCast(arg1);
18839     } CALL_CATCH_EXCEPTION(0);
18840   }
18841
18842   jresult = new Dali::GestureDetector((const Dali::GestureDetector &)result);
18843   return jresult;
18844 }
18845
18846
18847 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GestureDetector(void * jarg1) {
18848   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
18849
18850   arg1 = (Dali::GestureDetector *)jarg1;
18851   {
18852     try {
18853       delete arg1;
18854     } CALL_CATCH_EXCEPTION();
18855   }
18856
18857 }
18858
18859
18860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_1(void * jarg1) {
18861   void * jresult ;
18862   Dali::GestureDetector *arg1 = 0 ;
18863   Dali::GestureDetector *result = 0 ;
18864
18865   arg1 = (Dali::GestureDetector *)jarg1;
18866   if (!arg1) {
18867     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
18868     return 0;
18869   }
18870   {
18871     try {
18872       result = (Dali::GestureDetector *)new Dali::GestureDetector((Dali::GestureDetector const &)*arg1);
18873     } CALL_CATCH_EXCEPTION(0);
18874   }
18875
18876   jresult = (void *)result;
18877   return jresult;
18878 }
18879
18880
18881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_Assign(void * jarg1, void * jarg2) {
18882   void * jresult ;
18883   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
18884   Dali::GestureDetector *arg2 = 0 ;
18885   Dali::GestureDetector *result = 0 ;
18886
18887   arg1 = (Dali::GestureDetector *)jarg1;
18888   arg2 = (Dali::GestureDetector *)jarg2;
18889   if (!arg2) {
18890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
18891     return 0;
18892   }
18893   {
18894     try {
18895       result = (Dali::GestureDetector *) &(arg1)->operator =((Dali::GestureDetector const &)*arg2);
18896     } CALL_CATCH_EXCEPTION(0);
18897   }
18898
18899   jresult = (void *)result;
18900   return jresult;
18901 }
18902
18903
18904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Attach(void * jarg1, void * jarg2) {
18905   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
18906   Dali::Actor arg2 ;
18907   Dali::Actor *argp2 ;
18908
18909   arg1 = (Dali::GestureDetector *)jarg1;
18910   argp2 = (Dali::Actor *)jarg2;
18911   if (!argp2) {
18912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
18913     return ;
18914   }
18915   arg2 = *argp2;
18916   {
18917     try {
18918       (arg1)->Attach(arg2);
18919     } CALL_CATCH_EXCEPTION();
18920   }
18921
18922 }
18923
18924
18925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Detach(void * jarg1, void * jarg2) {
18926   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
18927   Dali::Actor arg2 ;
18928   Dali::Actor *argp2 ;
18929
18930   arg1 = (Dali::GestureDetector *)jarg1;
18931   argp2 = (Dali::Actor *)jarg2;
18932   if (!argp2) {
18933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
18934     return ;
18935   }
18936   arg2 = *argp2;
18937   {
18938     try {
18939       (arg1)->Detach(arg2);
18940     } CALL_CATCH_EXCEPTION();
18941   }
18942
18943 }
18944
18945
18946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_DetachAll(void * jarg1) {
18947   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
18948
18949   arg1 = (Dali::GestureDetector *)jarg1;
18950   {
18951     try {
18952       (arg1)->DetachAll();
18953     } CALL_CATCH_EXCEPTION();
18954   }
18955
18956 }
18957
18958
18959 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActorCount(void * jarg1) {
18960   unsigned long jresult ;
18961   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
18962   size_t result;
18963
18964   arg1 = (Dali::GestureDetector *)jarg1;
18965   {
18966     try {
18967       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActorCount();
18968     } CALL_CATCH_EXCEPTION(0);
18969   }
18970
18971   jresult = (unsigned long)result;
18972   return jresult;
18973 }
18974
18975
18976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActor(void * jarg1, unsigned long jarg2) {
18977   void * jresult ;
18978   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
18979   size_t arg2 ;
18980   Dali::Actor result;
18981
18982   arg1 = (Dali::GestureDetector *)jarg1;
18983   arg2 = (size_t)jarg2;
18984   {
18985     try {
18986       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActor(arg2);
18987     } CALL_CATCH_EXCEPTION(0);
18988   }
18989
18990   jresult = new Dali::Actor((const Dali::Actor &)result);
18991   return jresult;
18992 }
18993
18994
18995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Gesture(void * jarg1) {
18996   void * jresult ;
18997   Dali::Gesture *arg1 = 0 ;
18998   Dali::Gesture *result = 0 ;
18999
19000   arg1 = (Dali::Gesture *)jarg1;
19001   if (!arg1) {
19002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
19003     return 0;
19004   }
19005   {
19006     try {
19007       result = (Dali::Gesture *)new Dali::Gesture((Dali::Gesture const &)*arg1);
19008     } CALL_CATCH_EXCEPTION(0);
19009   }
19010
19011   jresult = (void *)result;
19012   return jresult;
19013 }
19014
19015
19016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Gesture_Assign(void * jarg1, void * jarg2) {
19017   void * jresult ;
19018   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
19019   Dali::Gesture *arg2 = 0 ;
19020   Dali::Gesture *result = 0 ;
19021
19022   arg1 = (Dali::Gesture *)jarg1;
19023   arg2 = (Dali::Gesture *)jarg2;
19024   if (!arg2) {
19025     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
19026     return 0;
19027   }
19028   {
19029     try {
19030       result = (Dali::Gesture *) &(arg1)->operator =((Dali::Gesture const &)*arg2);
19031     } CALL_CATCH_EXCEPTION(0);
19032   }
19033
19034   jresult = (void *)result;
19035   return jresult;
19036 }
19037
19038
19039 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Gesture(void * jarg1) {
19040   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
19041
19042   arg1 = (Dali::Gesture *)jarg1;
19043   {
19044     try {
19045       delete arg1;
19046     } CALL_CATCH_EXCEPTION();
19047   }
19048
19049 }
19050
19051 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 unsigned long SWIGSTDCALL CSharp_Dali_Hover_GetTime(void * jarg1) {
19174   unsigned long jresult ;
19175   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
19176   unsigned long result;
19177
19178   arg1 = (Dali::HoverEvent *)jarg1;
19179   {
19180     try {
19181       result = (unsigned long)((Dali::HoverEvent const *)arg1)->GetTime();
19182     } catch (std::out_of_range& e) {
19183       {
19184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19185       };
19186     } catch (std::exception& e) {
19187       {
19188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19189       };
19190     } catch (Dali::DaliException e) {
19191       {
19192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19193       };
19194     } catch (...) {
19195       {
19196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19197       };
19198     }
19199   }
19200
19201   jresult = (unsigned long)result;
19202   return jresult;
19203 }
19204
19205
19206 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_GetPointCount(void * jarg1) {
19207   unsigned long jresult ;
19208   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
19209   std::size_t result;
19210
19211   arg1 = (Dali::HoverEvent *)jarg1;
19212   {
19213     try {
19214       result = ((Dali::HoverEvent const *)arg1)->GetPointCount();
19215     } catch (std::out_of_range& e) {
19216       {
19217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19218       };
19219     } catch (std::exception& e) {
19220       {
19221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19222       };
19223     } catch (Dali::DaliException e) {
19224       {
19225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19226       };
19227     } catch (...) {
19228       {
19229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19230       };
19231     }
19232   }
19233
19234   jresult = (unsigned long)result;
19235   return jresult;
19236 }
19237
19238
19239 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Hover_GetDeviceId(void * jarg1, unsigned long jarg2) {
19240   int jresult ;
19241   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
19242   std::size_t arg2 ;
19243   int32_t result;
19244
19245   arg1 = (Dali::HoverEvent *)jarg1;
19246   arg2 = (std::size_t)jarg2;
19247   {
19248     try {
19249       result = ((Dali::HoverEvent const *)arg1)->GetDeviceId(arg2);
19250     } catch (std::out_of_range& e) {
19251       {
19252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19253       };
19254     } catch (std::exception& e) {
19255       {
19256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19257       };
19258     } catch (Dali::DaliException e) {
19259       {
19260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19261       };
19262     } catch (...) {
19263       {
19264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19265       };
19266     }
19267   }
19268
19269   jresult = result;
19270   return jresult;
19271 }
19272
19273
19274 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Hover_GetState(void * jarg1, unsigned long jarg2) {
19275   int jresult ;
19276   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
19277   std::size_t arg2 ;
19278   Dali::PointState::Type result;
19279
19280   arg1 = (Dali::HoverEvent *)jarg1;
19281   arg2 = (std::size_t)jarg2;
19282   {
19283     try {
19284       result = (Dali::PointState::Type)((Dali::HoverEvent const *)arg1)->GetState(arg2);
19285     } CALL_CATCH_EXCEPTION(0);
19286   }
19287
19288   jresult = (int)result;
19289   return jresult;
19290 }
19291
19292
19293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetHitActor(void * jarg1, unsigned long jarg2) {
19294   void * jresult ;
19295   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
19296   std::size_t arg2 ;
19297   Dali::Actor result;
19298
19299   arg1 = (Dali::HoverEvent *)jarg1;
19300   arg2 = (std::size_t)jarg2;
19301   {
19302     try {
19303       result = ((Dali::HoverEvent const *)arg1)->GetHitActor(arg2);
19304     } catch (std::out_of_range& e) {
19305       {
19306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19307       };
19308     } catch (std::exception& e) {
19309       {
19310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19311       };
19312     } catch (Dali::DaliException e) {
19313       {
19314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19315       };
19316     } catch (...) {
19317       {
19318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19319       };
19320     }
19321   }
19322
19323   jresult = new Dali::Actor((const Dali::Actor &)result);
19324   return jresult;
19325 }
19326
19327
19328 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetLocalPosition(void * jarg1, unsigned long jarg2) {
19329   void * jresult ;
19330   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
19331   std::size_t arg2 ;
19332   Dali::Vector2 *result = 0 ;
19333
19334   arg1 = (Dali::HoverEvent *)jarg1;
19335   arg2 = (std::size_t)jarg2;
19336   {
19337     try {
19338       result = (Dali::Vector2 *) &((Dali::HoverEvent const *)arg1)->GetLocalPosition(arg2);
19339     } catch (std::out_of_range& e) {
19340       {
19341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19342       };
19343     } catch (std::exception& e) {
19344       {
19345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19346       };
19347     } catch (Dali::DaliException e) {
19348       {
19349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19350       };
19351     } catch (...) {
19352       {
19353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19354       };
19355     }
19356   }
19357
19358   jresult = (void *)result;
19359   return jresult;
19360 }
19361
19362
19363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetScreenPosition(void * jarg1, unsigned long jarg2) {
19364   void * jresult ;
19365   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
19366   std::size_t arg2 ;
19367   Dali::Vector2 *result = 0 ;
19368
19369   arg1 = (Dali::HoverEvent *)jarg1;
19370   arg2 = (std::size_t)jarg2;
19371   {
19372     try {
19373       result = (Dali::Vector2 *) &((Dali::HoverEvent const *)arg1)->GetScreenPosition(arg2);
19374     } CALL_CATCH_EXCEPTION(0);
19375   }
19376
19377   jresult = (void *)result;
19378   return jresult;
19379 }
19380
19381
19382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_0() {
19383   void * jresult ;
19384   Dali::KeyEvent *result = 0 ;
19385
19386   {
19387     try {
19388       result = (Dali::KeyEvent *)new Dali::KeyEvent();
19389     } CALL_CATCH_EXCEPTION(0);
19390   }
19391
19392   jresult = (void *)result;
19393   return jresult;
19394 }
19395
19396
19397 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_1(void * jarg1) {
19398   void * jresult ;
19399   Dali::KeyEvent *arg1 = 0 ;
19400   Dali::KeyEvent *result = 0 ;
19401
19402   arg1 = (Dali::KeyEvent *)jarg1;
19403   if (!arg1) {
19404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
19405     return 0;
19406   }
19407   {
19408     try {
19409       result = (Dali::KeyEvent *)new Dali::KeyEvent((Dali::KeyEvent const &)*arg1);
19410     } CALL_CATCH_EXCEPTION(0);
19411   }
19412
19413   jresult = (void *)result;
19414   return jresult;
19415 }
19416
19417
19418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_Assign(void * jarg1, void * jarg2) {
19419   void * jresult ;
19420   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
19421   Dali::KeyEvent *arg2 = 0 ;
19422   Dali::KeyEvent *result = 0 ;
19423
19424   arg1 = (Dali::KeyEvent *)jarg1;
19425   arg2 = (Dali::KeyEvent *)jarg2;
19426   if (!arg2) {
19427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
19428     return 0;
19429   }
19430   {
19431     try {
19432       result = (Dali::KeyEvent *) &(arg1)->operator =((Dali::KeyEvent const &)*arg2);
19433     } CALL_CATCH_EXCEPTION(0);
19434   }
19435
19436   jresult = (void *)result;
19437   return jresult;
19438 }
19439
19440
19441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_New(char * jarg1, char * jarg2, int jarg3, int jarg4, unsigned long jarg5, int jarg6) {
19442   void * jresult ;
19443   std::string *arg1 = 0 ;
19444   std::string *arg2 = 0 ;
19445   int arg3 ;
19446   int arg4 ;
19447   unsigned long arg5 ;
19448   Dali::KeyEvent::State *arg6 = 0 ;
19449   Dali::KeyEvent::State temp6 ;
19450   Dali::KeyEvent result;
19451
19452   if (!jarg1) {
19453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19454     return 0;
19455   }
19456   std::string arg1_str(jarg1);
19457   arg1 = &arg1_str;
19458   if (!jarg2) {
19459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19460     return 0;
19461   }
19462   std::string arg2_str(jarg2);
19463   arg2 = &arg2_str;
19464   arg3 = (int)jarg3;
19465   arg4 = (int)jarg4;
19466   arg5 = (unsigned long)jarg5;
19467   temp6 = (Dali::KeyEvent::State)jarg6;
19468   arg6 = &temp6;
19469   {
19470     try {
19471       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);
19472     } CALL_CATCH_EXCEPTION(0);
19473   }
19474
19475   jresult = new Dali::KeyEvent((const Dali::KeyEvent &)result);
19476
19477   //argout typemap for const std::string&
19478
19479
19480   //argout typemap for const std::string&
19481
19482   return jresult;
19483 }
19484
19485 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Key(void * jarg1) {
19486   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
19487
19488   arg1 = (Dali::KeyEvent *)jarg1;
19489   {
19490     try {
19491       delete arg1;
19492     } CALL_CATCH_EXCEPTION();
19493   }
19494
19495 }
19496
19497
19498 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsShiftModifier(void * jarg1) {
19499   unsigned int jresult ;
19500   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
19501   bool result;
19502
19503   arg1 = (Dali::KeyEvent *)jarg1;
19504   {
19505     try {
19506       result = (bool)((Dali::KeyEvent const *)arg1)->IsShiftModifier();
19507     } CALL_CATCH_EXCEPTION(0);
19508   }
19509
19510   jresult = result;
19511   return jresult;
19512 }
19513
19514
19515 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsCtrlModifier(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)->IsCtrlModifier();
19524     } CALL_CATCH_EXCEPTION(0);
19525   }
19526
19527   jresult = result;
19528   return jresult;
19529 }
19530
19531
19532 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsAltModifier(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)->IsAltModifier();
19541     } CALL_CATCH_EXCEPTION(0);
19542   }
19543
19544   jresult = result;
19545   return jresult;
19546 }
19547
19548
19549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressedName_set(void * jarg1, char * jarg2) {
19550   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0 ;
19551   std::string *arg2 = 0 ;
19552
19553   Dali::KeyEvent arg1 = *argp1;
19554   if (!jarg2) {
19555     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19556     return ;
19557   }
19558   std::string arg2_str(jarg2);
19559   arg2 = &arg2_str;
19560
19561   {
19562     try {
19563       Dali::DevelKeyEvent::SetKeyName(arg1, (std::string const &)*arg2);
19564     } catch (std::out_of_range& e) {
19565       {
19566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19567       };
19568     } catch (std::exception& e) {
19569       {
19570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19571       };
19572     } catch (Dali::DaliException e) {
19573       {
19574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19575       };
19576     } catch (...) {
19577       {
19578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19579       };
19580     }
19581   }
19582 }
19583
19584
19585 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressedName_get(void * jarg1) {
19586   char * jresult ;
19587
19588   if( jarg1 == NULL )
19589   {
19590     jresult = SWIG_csharp_string_callback( "" );
19591   }
19592   else
19593   {
19594     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
19595     std::string *result = 0;
19596
19597     arg1 = ( Dali::KeyEvent * )jarg1;
19598     {
19599       try {
19600         std::string str = ((Dali::KeyEvent const *)arg1)->GetKeyName();
19601         result = (std::string *) &str;
19602       } catch (std::out_of_range& e) {
19603         {
19604           SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19605         };
19606       } catch (std::exception& e) {
19607         {
19608           SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19609         };
19610       } catch (Dali::DaliException e) {
19611         {
19612           SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19613         };
19614       } catch (...) {
19615         {
19616           SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19617         };
19618       }
19619     }
19620
19621     jresult = SWIG_csharp_string_callback(result->c_str());
19622   }
19623
19624   return jresult;
19625 }
19626
19627
19628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressed_set(void * jarg1, char * jarg2) {
19629   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0 ;
19630   std::string *arg2 = 0 ;
19631
19632   Dali::KeyEvent arg1 = *argp1;
19633   if (!jarg2) {
19634     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19635     return ;
19636   }
19637   std::string arg2_str(jarg2);
19638   arg2 = &arg2_str;
19639
19640   {
19641     try {
19642       Dali::DevelKeyEvent::SetKeyString(arg1, (std::string const &)*arg2);
19643     } catch (std::out_of_range& e) {
19644       {
19645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19646       };
19647     } catch (std::exception& e) {
19648       {
19649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19650       };
19651     } catch (Dali::DaliException e) {
19652       {
19653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19654       };
19655     } catch (...) {
19656       {
19657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19658       };
19659     }
19660   }
19661 }
19662
19663
19664 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressed_get(void * jarg1) {
19665   char * jresult ;
19666
19667   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
19668   std::string *result = 0;
19669
19670   arg1 = ( Dali::KeyEvent * )jarg1;
19671   {
19672     try {
19673       std::string str = ((Dali::KeyEvent const *)arg1)->GetKeyString();
19674       result = (std::string *) &str;
19675     } catch (std::out_of_range& e) {
19676       {
19677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19678       };
19679     } catch (std::exception& e) {
19680       {
19681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19682       };
19683     } catch (Dali::DaliException e) {
19684       {
19685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19686       };
19687     } catch (...) {
19688       {
19689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19690       };
19691     }
19692
19693     jresult = SWIG_csharp_string_callback(result->c_str());
19694   }
19695
19696   return jresult;
19697 }
19698
19699
19700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyCode_set(void * jarg1, int jarg2) {
19701   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0 ;
19702   int arg2 ;
19703
19704   Dali::KeyEvent arg1 = *argp1;
19705   arg2 = (int)jarg2;
19706   {
19707     try {
19708       Dali::DevelKeyEvent::SetKeyCode(arg1, arg2);
19709     } catch (std::out_of_range& e) {
19710       {
19711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19712       };
19713     } catch (std::exception& e) {
19714       {
19715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19716       };
19717     } catch (Dali::DaliException e) {
19718       {
19719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19720       };
19721     } catch (...) {
19722       {
19723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19724       };
19725     }
19726   }
19727 }
19728
19729
19730 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyCode_get(void * jarg1) {
19731   int jresult ;
19732   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
19733   int result;
19734
19735   arg1 = (Dali::KeyEvent *)jarg1;
19736   {
19737     try {
19738       result = (int)((Dali::KeyEvent const *)arg1)->GetKeyCode();
19739     } catch (std::out_of_range& e) {
19740       {
19741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19742       };
19743     } catch (std::exception& e) {
19744       {
19745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19746       };
19747     } catch (Dali::DaliException e) {
19748       {
19749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19750       };
19751     } catch (...) {
19752       {
19753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19754       };
19755     }
19756   }
19757
19758   jresult = result;
19759   return jresult;
19760 }
19761
19762
19763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyModifier_set(void * jarg1, int jarg2) {
19764   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0 ;
19765   int arg2 ;
19766
19767   Dali::KeyEvent arg1 = *argp1;
19768   arg2 = (int)jarg2;
19769   {
19770     try {
19771       Dali::DevelKeyEvent::SetKeyModifier(arg1, arg2);
19772     } catch (std::out_of_range& e) {
19773       {
19774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19775       };
19776     } catch (std::exception& e) {
19777       {
19778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19779       };
19780     } catch (Dali::DaliException e) {
19781       {
19782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19783       };
19784     } catch (...) {
19785       {
19786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19787       };
19788     }
19789   }
19790 }
19791
19792
19793 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyModifier_get(void * jarg1) {
19794   int jresult ;
19795   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
19796   int result;
19797
19798   arg1 = (Dali::KeyEvent *)jarg1;
19799   {
19800     try {
19801       result = (int)((Dali::KeyEvent const *)arg1)->GetKeyModifier();
19802     } catch (std::out_of_range& e) {
19803       {
19804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19805       };
19806     } catch (std::exception& e) {
19807       {
19808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19809       };
19810     } catch (Dali::DaliException e) {
19811       {
19812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19813       };
19814     } catch (...) {
19815       {
19816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19817       };
19818     }
19819   }
19820
19821   jresult = result;
19822   return jresult;
19823 }
19824
19825
19826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_time_set(void * jarg1, unsigned long jarg2) {
19827   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0 ;
19828   unsigned long arg2 ;
19829
19830   Dali::KeyEvent arg1 = *argp1;
19831   arg2 = (int)jarg2;
19832   {
19833     try {
19834       Dali::DevelKeyEvent::SetTime(arg1, arg2);
19835     } catch (std::out_of_range& e) {
19836       {
19837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19838       };
19839     } catch (std::exception& e) {
19840       {
19841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19842       };
19843     } catch (Dali::DaliException e) {
19844       {
19845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19846       };
19847     } catch (...) {
19848       {
19849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19850       };
19851     }
19852   }
19853 }
19854
19855
19856 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Key_time_get(void * jarg1) {
19857   unsigned long jresult ;
19858   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
19859   unsigned long result;
19860
19861   arg1 = (Dali::KeyEvent *)jarg1;
19862   {
19863     try {
19864       result = (int)((Dali::KeyEvent const *)arg1)->GetTime();
19865     } catch (std::out_of_range& e) {
19866       {
19867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19868       };
19869     } catch (std::exception& e) {
19870       {
19871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19872       };
19873     } catch (Dali::DaliException e) {
19874       {
19875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19876       };
19877     } catch (...) {
19878       {
19879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19880       };
19881     }
19882   }
19883
19884   jresult = result;
19885   return jresult;
19886 }
19887
19888
19889 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_state_set(void * jarg1, int jarg2) {
19890   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0;
19891   Dali::KeyEvent::State arg2;
19892
19893   Dali::KeyEvent arg1 = *argp1;
19894   arg2 = (Dali::KeyEvent::State)jarg2;
19895   {
19896     try {
19897       Dali::DevelKeyEvent::SetState(arg1, arg2);
19898     } catch (std::out_of_range& e) {
19899       {
19900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19901       };
19902     } catch (std::exception& e) {
19903       {
19904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19905       };
19906     } catch (Dali::DaliException e) {
19907       {
19908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19909       };
19910     } catch (...) {
19911       {
19912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19913       };
19914     }
19915   }
19916 }
19917
19918
19919 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_state_get(void * jarg1) {
19920   int jresult ;
19921   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
19922   Dali::KeyEvent::State result;
19923
19924   arg1 = (Dali::KeyEvent *)jarg1;
19925   {
19926     try {
19927       result = (Dali::KeyEvent::State)((Dali::KeyEvent const *)arg1)->GetState();
19928     } catch (std::out_of_range& e) {
19929       {
19930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19931       };
19932     } catch (std::exception& e) {
19933       {
19934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19935       };
19936     } catch (Dali::DaliException e) {
19937       {
19938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19939       };
19940     } catch (...) {
19941       {
19942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19943       };
19944     }
19945   }
19946
19947   jresult = (int)result;
19948   return jresult;
19949
19950 }
19951
19952 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_logicalKey_get(void * jarg1) {
19953   char * jresult ;
19954
19955   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
19956   std::string *result = 0;
19957
19958   arg1 = ( Dali::KeyEvent * )jarg1;
19959   {
19960     try {
19961       std::string str = ((Dali::KeyEvent const *)arg1)->GetLogicalKey();
19962       result = (std::string *) &str;
19963     } CALL_CATCH_EXCEPTION(0);
19964
19965   }
19966
19967   jresult = SWIG_csharp_string_callback(result->c_str());
19968   return jresult;
19969 }
19970
19971
19972 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_0() {
19973   void * jresult ;
19974   Dali::LongPressGestureDetector *result = 0 ;
19975
19976   {
19977     try {
19978       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector();
19979     } CALL_CATCH_EXCEPTION(0);
19980   }
19981
19982   jresult = (void *)result;
19983   return jresult;
19984 }
19985
19986
19987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_0() {
19988   void * jresult ;
19989   Dali::LongPressGestureDetector result;
19990
19991   {
19992     try {
19993       result = Dali::LongPressGestureDetector::New();
19994     } CALL_CATCH_EXCEPTION(0);
19995   }
19996
19997   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
19998   return jresult;
19999 }
20000
20001
20002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_1(unsigned int jarg1) {
20003   void * jresult ;
20004   unsigned int arg1 ;
20005   Dali::LongPressGestureDetector result;
20006
20007   arg1 = (unsigned int)jarg1;
20008   {
20009     try {
20010       result = Dali::LongPressGestureDetector::New(arg1);
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_2(unsigned int jarg1, unsigned int jarg2) {
20020   void * jresult ;
20021   unsigned int arg1 ;
20022   unsigned int arg2 ;
20023   Dali::LongPressGestureDetector result;
20024
20025   arg1 = (unsigned int)jarg1;
20026   arg2 = (unsigned int)jarg2;
20027   {
20028     try {
20029       result = Dali::LongPressGestureDetector::New(arg1,arg2);
20030     } CALL_CATCH_EXCEPTION(0);
20031   }
20032
20033   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
20034   return jresult;
20035 }
20036
20037
20038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DownCast(void * jarg1) {
20039   void * jresult ;
20040   Dali::BaseHandle arg1 ;
20041   Dali::BaseHandle *argp1 ;
20042   Dali::LongPressGestureDetector result;
20043
20044   argp1 = (Dali::BaseHandle *)jarg1;
20045   if (!argp1) {
20046     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
20047     return 0;
20048   }
20049   arg1 = *argp1;
20050   {
20051     try {
20052       result = Dali::LongPressGestureDetector::DownCast(arg1);
20053     } CALL_CATCH_EXCEPTION(0);
20054   }
20055
20056   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
20057   return jresult;
20058 }
20059
20060
20061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetector(void * jarg1) {
20062   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
20063
20064   arg1 = (Dali::LongPressGestureDetector *)jarg1;
20065   {
20066     try {
20067       delete arg1;
20068     } CALL_CATCH_EXCEPTION();
20069   }
20070
20071 }
20072
20073
20074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_1(void * jarg1) {
20075   void * jresult ;
20076   Dali::LongPressGestureDetector *arg1 = 0 ;
20077   Dali::LongPressGestureDetector *result = 0 ;
20078
20079   arg1 = (Dali::LongPressGestureDetector *)jarg1;
20080   if (!arg1) {
20081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
20082     return 0;
20083   }
20084   {
20085     try {
20086       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector((Dali::LongPressGestureDetector const &)*arg1);
20087     } CALL_CATCH_EXCEPTION(0);
20088   }
20089
20090   jresult = (void *)result;
20091   return jresult;
20092 }
20093
20094
20095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_Assign(void * jarg1, void * jarg2) {
20096   void * jresult ;
20097   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
20098   Dali::LongPressGestureDetector *arg2 = 0 ;
20099   Dali::LongPressGestureDetector *result = 0 ;
20100
20101   arg1 = (Dali::LongPressGestureDetector *)jarg1;
20102   arg2 = (Dali::LongPressGestureDetector *)jarg2;
20103   if (!arg2) {
20104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
20105     return 0;
20106   }
20107   {
20108     try {
20109       result = (Dali::LongPressGestureDetector *) &(arg1)->operator =((Dali::LongPressGestureDetector const &)*arg2);
20110     } CALL_CATCH_EXCEPTION(0);
20111   }
20112
20113   jresult = (void *)result;
20114   return jresult;
20115 }
20116
20117
20118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_0(void * jarg1, unsigned int jarg2) {
20119   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
20120   unsigned int arg2 ;
20121
20122   arg1 = (Dali::LongPressGestureDetector *)jarg1;
20123   arg2 = (unsigned int)jarg2;
20124   {
20125     try {
20126       (arg1)->SetTouchesRequired(arg2);
20127     } CALL_CATCH_EXCEPTION();
20128   }
20129
20130 }
20131
20132
20133 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
20134   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
20135   unsigned int arg2 ;
20136   unsigned int arg3 ;
20137
20138   arg1 = (Dali::LongPressGestureDetector *)jarg1;
20139   arg2 = (unsigned int)jarg2;
20140   arg3 = (unsigned int)jarg3;
20141   {
20142     try {
20143       (arg1)->SetTouchesRequired(arg2,arg3);
20144     } CALL_CATCH_EXCEPTION();
20145   }
20146
20147 }
20148
20149
20150 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
20151   unsigned int jresult ;
20152   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
20153   unsigned int result;
20154
20155   arg1 = (Dali::LongPressGestureDetector *)jarg1;
20156   {
20157     try {
20158       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMinimumTouchesRequired();
20159     } CALL_CATCH_EXCEPTION(0);
20160   }
20161
20162   jresult = result;
20163   return jresult;
20164 }
20165
20166
20167 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMaximumTouchesRequired(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)->GetMaximumTouchesRequired();
20176     } CALL_CATCH_EXCEPTION(0);
20177   }
20178
20179   jresult = result;
20180   return jresult;
20181 }
20182
20183
20184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DetectedSignal(void * jarg1) {
20185   void * jresult ;
20186   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
20187   Dali::LongPressGestureDetector::DetectedSignalType *result = 0 ;
20188
20189   arg1 = (Dali::LongPressGestureDetector *)jarg1;
20190   {
20191     try {
20192       result = (Dali::LongPressGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
20193     } CALL_CATCH_EXCEPTION(0);
20194   }
20195
20196   jresult = (void *)result;
20197   return jresult;
20198 }
20199
20200
20201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_0() {
20202   void * jresult ;
20203   Dali::LongPressGesture *result = 0 ;
20204
20205   {
20206     try {
20207       result = (Dali::LongPressGesture *)new Dali::LongPressGesture();
20208     } CALL_CATCH_EXCEPTION(0);
20209   }
20210
20211   jresult = (void *)result;
20212   return jresult;
20213 }
20214
20215
20216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_1(void * jarg1) {
20217   void * jresult ;
20218   Dali::LongPressGesture *arg1 = 0 ;
20219   Dali::LongPressGesture *result = 0 ;
20220
20221   arg1 = (Dali::LongPressGesture *)jarg1;
20222   if (!arg1) {
20223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
20224     return 0;
20225   }
20226   {
20227     try {
20228       result = (Dali::LongPressGesture *)new Dali::LongPressGesture((Dali::LongPressGesture const &)*arg1);
20229     } CALL_CATCH_EXCEPTION(0);
20230   }
20231
20232   jresult = (void *)result;
20233   return jresult;
20234 }
20235
20236
20237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_Assign(void * jarg1, void * jarg2) {
20238   void * jresult ;
20239   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
20240   Dali::LongPressGesture *arg2 = 0 ;
20241   Dali::LongPressGesture *result = 0 ;
20242
20243   arg1 = (Dali::LongPressGesture *)jarg1;
20244   arg2 = (Dali::LongPressGesture *)jarg2;
20245   if (!arg2) {
20246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
20247     return 0;
20248   }
20249   {
20250     try {
20251       result = (Dali::LongPressGesture *) &(arg1)->operator =((Dali::LongPressGesture const &)*arg2);
20252     } CALL_CATCH_EXCEPTION(0);
20253   }
20254
20255   jresult = (void *)result;
20256   return jresult;
20257 }
20258
20259
20260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGesture(void * jarg1) {
20261   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
20262
20263   arg1 = (Dali::LongPressGesture *)jarg1;
20264   {
20265     try {
20266       delete arg1;
20267     } CALL_CATCH_EXCEPTION();
20268   }
20269
20270 }
20271
20272
20273 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_get(void * jarg1) {
20274   unsigned int jresult ;
20275   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
20276   unsigned int result;
20277
20278   arg1 = (Dali::LongPressGesture *)jarg1;
20279   result = (unsigned int) ((arg1)->GetNumberOfTouches());
20280   jresult = result;
20281   return jresult;
20282 }
20283
20284
20285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_get(void * jarg1) {
20286   void * jresult ;
20287   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
20288   Dali::Vector2 result;
20289
20290   arg1 = (Dali::LongPressGesture *)jarg1;
20291   {
20292     try {
20293       result = ((Dali::LongPressGesture const *)arg1)->GetScreenPoint();
20294     } catch (std::out_of_range& e) {
20295       {
20296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20297       };
20298     } catch (std::exception& e) {
20299       {
20300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20301       };
20302     } catch (Dali::DaliException e) {
20303       {
20304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20305       };
20306     } catch (...) {
20307       {
20308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20309       };
20310     }
20311   }
20312   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
20313   return jresult;
20314 }
20315
20316
20317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_get(void * jarg1) {
20318   void * jresult ;
20319   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
20320   Dali::Vector2 result;
20321
20322   arg1 = (Dali::LongPressGesture *)jarg1;
20323   {
20324     try {
20325       result = ((Dali::LongPressGesture const *)arg1)->GetLocalPoint();
20326     } catch (std::out_of_range& e) {
20327       {
20328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20329       };
20330     } catch (std::exception& e) {
20331       {
20332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20333       };
20334     } catch (Dali::DaliException e) {
20335       {
20336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20337       };
20338     } catch (...) {
20339       {
20340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20341       };
20342     }
20343   }
20344   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
20345   return jresult;
20346 }
20347
20348
20349 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_0() {
20350   void * jresult ;
20351   Dali::WheelEvent *result = 0 ;
20352
20353   {
20354     try {
20355       result = (Dali::WheelEvent *)new Dali::WheelEvent();
20356     } CALL_CATCH_EXCEPTION(0);
20357   }
20358
20359   jresult = (void *)result;
20360   return jresult;
20361 }
20362
20363
20364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_1(void * jarg1) {
20365   void * jresult ;
20366   Dali::WheelEvent *arg1 = 0 ;
20367   Dali::WheelEvent *result = 0 ;
20368
20369   arg1 = (Dali::WheelEvent *)jarg1;
20370   if (!arg1) {
20371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
20372     return 0;
20373   }
20374   {
20375     try {
20376       result = (Dali::WheelEvent *)new Dali::WheelEvent((Dali::WheelEvent const &)*arg1);
20377     } catch (std::out_of_range& e) {
20378       {
20379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20380       };
20381     } catch (std::exception& e) {
20382       {
20383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20384       };
20385     } catch (Dali::DaliException e) {
20386       {
20387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20388       };
20389     } catch (...) {
20390       {
20391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20392       };
20393     }
20394   }
20395
20396   jresult = (void *)result;
20397   return jresult;
20398 }
20399
20400
20401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_Assign(void * jarg1, void * jarg2) {
20402   void * jresult ;
20403   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
20404   Dali::WheelEvent *arg2 = 0 ;
20405   Dali::WheelEvent *result = 0 ;
20406
20407   arg1 = (Dali::WheelEvent *)jarg1;
20408   arg2 = (Dali::WheelEvent *)jarg2;
20409   if (!arg2) {
20410     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
20411     return 0;
20412   }
20413   {
20414     try {
20415       result = (Dali::WheelEvent *) &(arg1)->operator =((Dali::WheelEvent const &)*arg2);
20416     } catch (std::out_of_range& e) {
20417       {
20418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20419       };
20420     } catch (std::exception& e) {
20421       {
20422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20423       };
20424     } catch (Dali::DaliException e) {
20425       {
20426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20427       };
20428     } catch (...) {
20429       {
20430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20431       };
20432     }
20433   }
20434
20435   jresult = (void *)result;
20436   return jresult;
20437 }
20438
20439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_New(int jarg1, int jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6) {
20440   void * jresult ;
20441   Dali::WheelEvent::Type arg1 ;
20442   int arg2 ;
20443   unsigned int arg3 ;
20444   Dali::Vector2 arg4 ;
20445   int arg5 ;
20446   unsigned int arg6 ;
20447   Dali::Vector2 *argp4 ;
20448   Dali::WheelEvent result;
20449
20450   arg1 = (Dali::WheelEvent::Type)jarg1;
20451   arg2 = (int)jarg2;
20452   arg3 = (unsigned int)jarg3;
20453   argp4 = (Dali::Vector2 *)jarg4;
20454   if (!argp4) {
20455     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
20456     return 0;
20457   }
20458   arg4 = *argp4;
20459   arg5 = (int)jarg5;
20460   arg6 = (unsigned int)jarg6;
20461   {
20462     try {
20463       result = DevelWheelEvent::New(arg1,arg2,arg3,arg4,arg5,arg6);
20464     } CALL_CATCH_EXCEPTION(0);
20465   }
20466
20467   jresult = new Dali::WheelEvent((const Dali::WheelEvent &)result);
20468   return jresult;
20469 }
20470
20471
20472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Wheel(void * jarg1) {
20473   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
20474
20475   arg1 = (Dali::WheelEvent *)jarg1;
20476   {
20477     try {
20478       delete arg1;
20479     } CALL_CATCH_EXCEPTION();
20480   }
20481
20482 }
20483
20484
20485 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsShiftModifier(void * jarg1) {
20486   unsigned int jresult ;
20487   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
20488   bool result;
20489
20490   arg1 = (Dali::WheelEvent *)jarg1;
20491   {
20492     try {
20493       result = (bool)((Dali::WheelEvent const *)arg1)->IsShiftModifier();
20494     } CALL_CATCH_EXCEPTION(0);
20495   }
20496
20497   jresult = result;
20498   return jresult;
20499 }
20500
20501
20502 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsCtrlModifier(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)->IsCtrlModifier();
20511     } catch (std::out_of_range& e) {
20512       {
20513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20514       };
20515     } catch (std::exception& e) {
20516       {
20517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20518       };
20519     } catch (Dali::DaliException e) {
20520       {
20521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20522       };
20523     } catch (...) {
20524       {
20525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20526       };
20527     }
20528   }
20529
20530   jresult = result;
20531   return jresult;
20532 }
20533
20534
20535 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsAltModifier(void * jarg1) {
20536   unsigned int jresult ;
20537   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
20538   bool result;
20539
20540   arg1 = (Dali::WheelEvent *)jarg1;
20541   {
20542     try {
20543       result = (bool)((Dali::WheelEvent const *)arg1)->IsAltModifier();
20544     } catch (std::out_of_range& e) {
20545       {
20546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20547       };
20548     } catch (std::exception& e) {
20549       {
20550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20551       };
20552     } catch (Dali::DaliException e) {
20553       {
20554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20555       };
20556     } catch (...) {
20557       {
20558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20559       };
20560     }
20561   }
20562
20563   jresult = result;
20564   return jresult;
20565 }
20566
20567
20568 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_type_get(void * jarg1) {
20569   int jresult ;
20570   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
20571   Dali::WheelEvent::Type result;
20572
20573   arg1 = (Dali::WheelEvent *)jarg1;
20574   {
20575     try {
20576       result = ((Dali::WheelEvent const *)arg1)->GetType();
20577     } catch (std::out_of_range& e) {
20578       {
20579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20580       };
20581     } catch (std::exception& e) {
20582       {
20583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20584       };
20585     } catch (Dali::DaliException e) {
20586       {
20587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20588       };
20589     } catch (...) {
20590       {
20591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20592       };
20593     }
20594   }
20595
20596   jresult = (int)result;
20597   return jresult;
20598 }
20599
20600
20601 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_direction_get(void * jarg1) {
20602   int jresult ;
20603   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
20604   int result;
20605
20606   arg1 = (Dali::WheelEvent *)jarg1;
20607   {
20608     try {
20609       result = ((Dali::WheelEvent const *)arg1)->GetDirection();
20610     } catch (std::out_of_range& e) {
20611       {
20612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20613       };
20614     } catch (std::exception& e) {
20615       {
20616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20617       };
20618     } catch (Dali::DaliException e) {
20619       {
20620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20621       };
20622     } catch (...) {
20623       {
20624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20625       };
20626     }
20627   }
20628
20629   jresult = result;
20630   return jresult;
20631 }
20632
20633
20634 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_modifiers_get(void * jarg1) {
20635   unsigned int jresult ;
20636   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
20637   unsigned int result;
20638
20639   arg1 = (Dali::WheelEvent *)jarg1;
20640   {
20641     try {
20642       result = ((Dali::WheelEvent const *)arg1)->GetModifiers();
20643     } CALL_CATCH_EXCEPTION(0);
20644   }
20645
20646   jresult = result;
20647   return jresult;
20648 }
20649
20650
20651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_point_get(void * jarg1) {
20652   void * jresult ;
20653   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
20654   Dali::Vector2 *result = 0 ;
20655
20656   arg1 = (Dali::WheelEvent *)jarg1;
20657   {
20658     try {
20659       result = (Dali::Vector2 *) &((Dali::WheelEvent const *)arg1)->GetPoint();
20660     } CALL_CATCH_EXCEPTION(0);
20661   }
20662
20663   jresult = (void *)result;
20664   return jresult;
20665 }
20666
20667
20668 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_delta_get(void * jarg1) {
20669   int jresult ;
20670   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
20671   int result;
20672
20673   arg1 = (Dali::WheelEvent *)jarg1;
20674   {
20675     try {
20676       result = ((Dali::WheelEvent const *)arg1)->GetDelta();
20677     } catch (std::out_of_range& e) {
20678       {
20679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20680       };
20681     } catch (std::exception& e) {
20682       {
20683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20684       };
20685     } catch (Dali::DaliException e) {
20686       {
20687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20688       };
20689     } catch (...) {
20690       {
20691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20692       };
20693     }
20694   }
20695
20696   jresult = result;
20697   return jresult;
20698 }
20699
20700
20701 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_get(void * jarg1) {
20702   unsigned int jresult ;
20703   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
20704   unsigned int result;
20705
20706   arg1 = (Dali::WheelEvent *)jarg1;
20707   {
20708     try {
20709       result = ((Dali::WheelEvent const *)arg1)->GetTime();
20710     } catch (std::out_of_range& e) {
20711       {
20712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20713       };
20714     } catch (std::exception& e) {
20715       {
20716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20717       };
20718     } catch (Dali::DaliException e) {
20719       {
20720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20721       };
20722     } catch (...) {
20723       {
20724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20725       };
20726     }
20727   }
20728
20729   jresult = result;
20730   return jresult;
20731 }
20732
20733 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetDeviceName(void * jarg1) {
20734   char * jresult ;
20735   Dali::KeyEvent *arg1 = 0 ;
20736   std::string result;
20737
20738   arg1 = (Dali::KeyEvent *)jarg1;
20739   if (!arg1) {
20740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
20741     return 0;
20742   }
20743   {
20744     try {
20745       result = arg1->GetDeviceName();
20746     } CALL_CATCH_EXCEPTION(0);
20747   }
20748
20749   jresult = SWIG_csharp_string_callback((&result)->c_str());
20750   return jresult;
20751 }
20752
20753 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceClass(void * jarg1) {
20754   int jresult ;
20755   Dali::KeyEvent *arg1 = 0 ;
20756   Dali::Device::Class::Type result;
20757
20758   arg1 = (Dali::KeyEvent *)jarg1;
20759   if (!arg1) {
20760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
20761     return 0;
20762   }
20763   {
20764     try {
20765       result = (Dali::Device::Class::Type)arg1->GetDeviceClass();
20766     } CALL_CATCH_EXCEPTION(0);
20767   }
20768
20769   jresult = (int)result;
20770   return jresult;
20771 }
20772
20773 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceSubClass(void * jarg1) {
20774   int jresult ;
20775   Dali::KeyEvent *arg1 = 0 ;
20776   Dali::Device::Subclass::Type result;
20777
20778   arg1 = (Dali::KeyEvent *)jarg1;
20779   if (!arg1) {
20780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
20781     return 0;
20782   }
20783   {
20784     try {
20785       result = (Dali::Device::Subclass::Type)arg1->GetDeviceSubclass();
20786     } CALL_CATCH_EXCEPTION(0);
20787   }
20788
20789   jresult = (int)result;
20790   return jresult;
20791 }
20792
20793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Raise(void * jarg1) {
20794   Dali::Actor arg1 ;
20795   Dali::Actor *argp1 ;
20796
20797   argp1 = (Dali::Actor *)jarg1;
20798   if (!argp1) {
20799     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
20800     return ;
20801   }
20802   arg1 = *argp1;
20803   {
20804     try {
20805       arg1.Raise();
20806     } CALL_CATCH_EXCEPTION();
20807   }
20808
20809 }
20810
20811
20812 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Lower(void * jarg1) {
20813   Dali::Actor arg1 ;
20814   Dali::Actor *argp1 ;
20815
20816   argp1 = (Dali::Actor *)jarg1;
20817   if (!argp1) {
20818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
20819     return ;
20820   }
20821   arg1 = *argp1;
20822   {
20823     try {
20824       arg1.Lower();
20825     } CALL_CATCH_EXCEPTION();
20826   }
20827
20828 }
20829
20830
20831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseToTop(void * jarg1) {
20832   Dali::Actor arg1 ;
20833   Dali::Actor *argp1 ;
20834
20835   argp1 = (Dali::Actor *)jarg1;
20836   if (!argp1) {
20837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
20838     return ;
20839   }
20840   arg1 = *argp1;
20841   {
20842     try {
20843       arg1.RaiseToTop();
20844     } CALL_CATCH_EXCEPTION();
20845   }
20846
20847 }
20848
20849
20850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerToBottom(void * jarg1) {
20851   Dali::Actor arg1 ;
20852   Dali::Actor *argp1 ;
20853
20854   argp1 = (Dali::Actor *)jarg1;
20855   if (!argp1) {
20856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
20857     return ;
20858   }
20859   arg1 = *argp1;
20860   {
20861     try {
20862       arg1.LowerToBottom();
20863     } CALL_CATCH_EXCEPTION();
20864   }
20865
20866 }
20867
20868 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseAbove(void * jarg1, void * jarg2) {
20869   Dali::Actor arg1 ;
20870   Dali::Actor arg2 ;
20871   Dali::Actor *argp1 ;
20872   Dali::Actor *argp2 ;
20873
20874   argp1 = (Dali::Actor *)jarg1;
20875   if (!argp1) {
20876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
20877     return ;
20878   }
20879   arg1 = *argp1;
20880   argp2 = (Dali::Actor *)jarg2;
20881   if (!argp2) {
20882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
20883     return ;
20884   }
20885   arg2 = *argp2;
20886   {
20887     try {
20888       arg1.RaiseAbove(arg2);
20889     } CALL_CATCH_EXCEPTION();
20890   }
20891
20892 }
20893
20894
20895 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerBelow(void * jarg1, void * jarg2) {
20896   Dali::Actor arg1 ;
20897   Dali::Actor arg2 ;
20898   Dali::Actor *argp1 ;
20899   Dali::Actor *argp2 ;
20900
20901   argp1 = (Dali::Actor *)jarg1;
20902   if (!argp1) {
20903     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
20904     return ;
20905   }
20906   arg1 = *argp1;
20907   argp2 = (Dali::Actor *)jarg2;
20908   if (!argp2) {
20909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
20910     return ;
20911   }
20912   arg2 = *argp2;
20913   {
20914     try {
20915       arg1.LowerBelow(arg2);
20916     } CALL_CATCH_EXCEPTION();
20917   }
20918
20919 }
20920
20921
20922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisibilityChangedSignal(void * jarg1) {
20923   void * jresult ;
20924   Dali::Actor arg1 ;
20925   Dali::Actor *argp1 ;
20926   Dali::DevelActor::VisibilityChangedSignalType *result = 0 ;
20927
20928   argp1 = (Dali::Actor *)jarg1;
20929   if (!argp1) {
20930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
20931     return 0;
20932   }
20933   arg1 = *argp1;
20934   {
20935     try {
20936       result = (Dali::DevelActor::VisibilityChangedSignalType *) &Dali::DevelActor::VisibilityChangedSignal(arg1);
20937     } CALL_CATCH_EXCEPTION(0);
20938   }
20939
20940   jresult = (void *)result;
20941   return jresult;
20942 }
20943
20944
20945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutDirectionChangedSignal(void * jarg1) {
20946   void * jresult ;
20947   Dali::Actor *arg1 ;
20948   Dali::Actor::LayoutDirectionChangedSignalType *result = 0 ;
20949
20950   arg1 = (Dali::Actor *)jarg1;
20951   {
20952     try {
20953       result = (Dali::Actor::LayoutDirectionChangedSignalType *) &(arg1)->LayoutDirectionChangedSignal();
20954     } CALL_CATCH_EXCEPTION(0);
20955   }
20956
20957   jresult = (void *)result;
20958   return jresult;
20959 }
20960
20961
20962 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_get() {
20963   int jresult ;
20964   int result;
20965
20966   result = (int)Dali::Actor::Property::PARENT_ORIGIN;
20967   jresult = (int)result;
20968   return jresult;
20969 }
20970
20971
20972 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_X_get() {
20973   int jresult ;
20974   int result;
20975
20976   result = (int)Dali::Actor::Property::PARENT_ORIGIN_X;
20977   jresult = (int)result;
20978   return jresult;
20979 }
20980
20981
20982 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Y_get() {
20983   int jresult ;
20984   int result;
20985
20986   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Y;
20987   jresult = (int)result;
20988   return jresult;
20989 }
20990
20991
20992 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Z_get() {
20993   int jresult ;
20994   int result;
20995
20996   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Z;
20997   jresult = (int)result;
20998   return jresult;
20999 }
21000
21001
21002 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_get() {
21003   int jresult ;
21004   int result;
21005
21006   result = (int)Dali::Actor::Property::ANCHOR_POINT;
21007   jresult = (int)result;
21008   return jresult;
21009 }
21010
21011
21012 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_X_get() {
21013   int jresult ;
21014   int result;
21015
21016   result = (int)Dali::Actor::Property::ANCHOR_POINT_X;
21017   jresult = (int)result;
21018   return jresult;
21019 }
21020
21021
21022 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Y_get() {
21023   int jresult ;
21024   int result;
21025
21026   result = (int)Dali::Actor::Property::ANCHOR_POINT_Y;
21027   jresult = (int)result;
21028   return jresult;
21029 }
21030
21031
21032 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Z_get() {
21033   int jresult ;
21034   int result;
21035
21036   result = (int)Dali::Actor::Property::ANCHOR_POINT_Z;
21037   jresult = (int)result;
21038   return jresult;
21039 }
21040
21041
21042 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_get() {
21043   int jresult ;
21044   int result;
21045
21046   result = (int)Dali::Actor::Property::SIZE;
21047   jresult = (int)result;
21048   return jresult;
21049 }
21050
21051
21052 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_WIDTH_get() {
21053   int jresult ;
21054   int result;
21055
21056   result = (int)Dali::Actor::Property::SIZE_WIDTH;
21057   jresult = (int)result;
21058   return jresult;
21059 }
21060
21061
21062 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_HEIGHT_get() {
21063   int jresult ;
21064   int result;
21065
21066   result = (int)Dali::Actor::Property::SIZE_HEIGHT;
21067   jresult = (int)result;
21068   return jresult;
21069 }
21070
21071
21072 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_DEPTH_get() {
21073   int jresult ;
21074   int result;
21075
21076   result = (int)Dali::Actor::Property::SIZE_DEPTH;
21077   jresult = (int)result;
21078   return jresult;
21079 }
21080
21081
21082 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_get() {
21083   int jresult ;
21084   int result;
21085
21086   result = (int)Dali::Actor::Property::POSITION;
21087   jresult = (int)result;
21088   return jresult;
21089 }
21090
21091
21092 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_X_get() {
21093   int jresult ;
21094   int result;
21095
21096   result = (int)Dali::Actor::Property::POSITION_X;
21097   jresult = (int)result;
21098   return jresult;
21099 }
21100
21101
21102 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Y_get() {
21103   int jresult ;
21104   int result;
21105
21106   result = (int)Dali::Actor::Property::POSITION_Y;
21107   jresult = (int)result;
21108   return jresult;
21109 }
21110
21111
21112 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Z_get() {
21113   int jresult ;
21114   int result;
21115
21116   result = (int)Dali::Actor::Property::POSITION_Z;
21117   jresult = (int)result;
21118   return jresult;
21119 }
21120
21121
21122 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_get() {
21123   int jresult ;
21124   int result;
21125
21126   result = (int)Dali::Actor::Property::WORLD_POSITION;
21127   jresult = (int)result;
21128   return jresult;
21129 }
21130
21131
21132 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_X_get() {
21133   int jresult ;
21134   int result;
21135
21136   result = (int)Dali::Actor::Property::WORLD_POSITION_X;
21137   jresult = (int)result;
21138   return jresult;
21139 }
21140
21141
21142 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Y_get() {
21143   int jresult ;
21144   int result;
21145
21146   result = (int)Dali::Actor::Property::WORLD_POSITION_Y;
21147   jresult = (int)result;
21148   return jresult;
21149 }
21150
21151
21152 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Z_get() {
21153   int jresult ;
21154   int result;
21155
21156   result = (int)Dali::Actor::Property::WORLD_POSITION_Z;
21157   jresult = (int)result;
21158   return jresult;
21159 }
21160
21161
21162 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ORIENTATION_get() {
21163   int jresult ;
21164   int result;
21165
21166   result = (int)Dali::Actor::Property::ORIENTATION;
21167   jresult = (int)result;
21168   return jresult;
21169 }
21170
21171
21172 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_ORIENTATION_get() {
21173   int jresult ;
21174   int result;
21175
21176   result = (int)Dali::Actor::Property::WORLD_ORIENTATION;
21177   jresult = (int)result;
21178   return jresult;
21179 }
21180
21181
21182 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_get() {
21183   int jresult ;
21184   int result;
21185
21186   result = (int)Dali::Actor::Property::SCALE;
21187   jresult = (int)result;
21188   return jresult;
21189 }
21190
21191
21192 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_X_get() {
21193   int jresult ;
21194   int result;
21195
21196   result = (int)Dali::Actor::Property::SCALE_X;
21197   jresult = (int)result;
21198   return jresult;
21199 }
21200
21201
21202 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Y_get() {
21203   int jresult ;
21204   int result;
21205
21206   result = (int)Dali::Actor::Property::SCALE_Y;
21207   jresult = (int)result;
21208   return jresult;
21209 }
21210
21211
21212 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Z_get() {
21213   int jresult ;
21214   int result;
21215
21216   result = (int)Dali::Actor::Property::SCALE_Z;
21217   jresult = (int)result;
21218   return jresult;
21219 }
21220
21221
21222 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_SCALE_get() {
21223   int jresult ;
21224   int result;
21225
21226   result = (int)Dali::Actor::Property::WORLD_SCALE;
21227   jresult = (int)result;
21228   return jresult;
21229 }
21230
21231
21232 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_VISIBLE_get() {
21233   int jresult ;
21234   int result;
21235
21236   result = (int)Dali::Actor::Property::VISIBLE;
21237   jresult = (int)result;
21238   return jresult;
21239 }
21240
21241
21242 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_get() {
21243   int jresult ;
21244   int result;
21245
21246   result = (int)Dali::Actor::Property::COLOR;
21247   jresult = (int)result;
21248   return jresult;
21249 }
21250
21251
21252 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_RED_get() {
21253   int jresult ;
21254   int result;
21255
21256   result = (int)Dali::Actor::Property::COLOR_RED;
21257   jresult = (int)result;
21258   return jresult;
21259 }
21260
21261
21262 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_GREEN_get() {
21263   int jresult ;
21264   int result;
21265
21266   result = (int)Dali::Actor::Property::COLOR_GREEN;
21267   jresult = (int)result;
21268   return jresult;
21269 }
21270
21271
21272 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_BLUE_get() {
21273   int jresult ;
21274   int result;
21275
21276   result = (int)Dali::Actor::Property::COLOR_BLUE;
21277   jresult = (int)result;
21278   return jresult;
21279 }
21280
21281
21282 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_ALPHA_get() {
21283   int jresult ;
21284   int result;
21285
21286   result = (int)Dali::Actor::Property::COLOR_ALPHA;
21287   jresult = (int)result;
21288   return jresult;
21289 }
21290
21291
21292 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_COLOR_get() {
21293   int jresult ;
21294   int result;
21295
21296   result = (int)Dali::Actor::Property::WORLD_COLOR;
21297   jresult = (int)result;
21298   return jresult;
21299 }
21300
21301
21302 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_MATRIX_get() {
21303   int jresult ;
21304   int result;
21305
21306   result = (int)Dali::Actor::Property::WORLD_MATRIX;
21307   jresult = (int)result;
21308   return jresult;
21309 }
21310
21311
21312 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_NAME_get() {
21313   int jresult ;
21314   int result;
21315
21316   result = (int)Dali::Actor::Property::NAME;
21317   jresult = (int)result;
21318   return jresult;
21319 }
21320
21321
21322 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SENSITIVE_get() {
21323   int jresult ;
21324   int result;
21325
21326   result = (int)Dali::Actor::Property::SENSITIVE;
21327   jresult = (int)result;
21328   return jresult;
21329 }
21330
21331
21332 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_LEAVE_REQUIRED_get() {
21333   int jresult ;
21334   int result;
21335
21336   result = (int)Dali::Actor::Property::LEAVE_REQUIRED;
21337   jresult = (int)result;
21338   return jresult;
21339 }
21340
21341
21342 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_ORIENTATION_get() {
21343   int jresult ;
21344   int result;
21345
21346   result = (int)Dali::Actor::Property::INHERIT_ORIENTATION;
21347   jresult = (int)result;
21348   return jresult;
21349 }
21350
21351
21352 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_SCALE_get() {
21353   int jresult ;
21354   int result;
21355
21356   result = (int)Dali::Actor::Property::INHERIT_SCALE;
21357   jresult = (int)result;
21358   return jresult;
21359 }
21360
21361
21362 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_MODE_get() {
21363   int jresult ;
21364   int result;
21365
21366   result = (int)Dali::Actor::Property::COLOR_MODE;
21367   jresult = (int)result;
21368   return jresult;
21369 }
21370
21371
21372 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_DRAW_MODE_get() {
21373   int jresult ;
21374   int result;
21375
21376   result = (int)Dali::Actor::Property::DRAW_MODE;
21377   jresult = (int)result;
21378   return jresult;
21379 }
21380
21381
21382 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_MODE_FACTOR_get() {
21383   int jresult ;
21384   int result;
21385
21386   result = (int)Dali::Actor::Property::SIZE_MODE_FACTOR;
21387   jresult = (int)result;
21388   return jresult;
21389 }
21390
21391
21392 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_RESIZE_POLICY_get() {
21393   int jresult ;
21394   int result;
21395
21396   result = (int)Dali::Actor::Property::WIDTH_RESIZE_POLICY;
21397   jresult = (int)result;
21398   return jresult;
21399 }
21400
21401
21402 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_RESIZE_POLICY_get() {
21403   int jresult ;
21404   int result;
21405
21406   result = (int)Dali::Actor::Property::HEIGHT_RESIZE_POLICY;
21407   jresult = (int)result;
21408   return jresult;
21409 }
21410
21411
21412 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_SCALE_POLICY_get() {
21413   int jresult ;
21414   int result;
21415
21416   result = (int)Dali::Actor::Property::SIZE_SCALE_POLICY;
21417   jresult = (int)result;
21418   return jresult;
21419 }
21420
21421
21422 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_FOR_HEIGHT_get() {
21423   int jresult ;
21424   int result;
21425
21426   result = (int)Dali::Actor::Property::WIDTH_FOR_HEIGHT;
21427   jresult = (int)result;
21428   return jresult;
21429 }
21430
21431
21432 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_FOR_WIDTH_get() {
21433   int jresult ;
21434   int result;
21435
21436   result = (int)Dali::Actor::Property::HEIGHT_FOR_WIDTH;
21437   jresult = (int)result;
21438   return jresult;
21439 }
21440
21441
21442 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PADDING_get() {
21443   int jresult ;
21444   int result;
21445
21446   result = (int)Dali::Actor::Property::PADDING;
21447   jresult = (int)result;
21448   return jresult;
21449 }
21450
21451
21452 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MINIMUM_SIZE_get() {
21453   int jresult ;
21454   int result;
21455
21456   result = (int)Dali::Actor::Property::MINIMUM_SIZE;
21457   jresult = (int)result;
21458   return jresult;
21459 }
21460
21461
21462 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MAXIMUM_SIZE_get() {
21463   int jresult ;
21464   int result;
21465
21466   result = (int)Dali::Actor::Property::MAXIMUM_SIZE;
21467   jresult = (int)result;
21468   return jresult;
21469 }
21470
21471
21472 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_POSITION_get() {
21473   int jresult ;
21474   int result;
21475
21476   result = (int)Dali::Actor::Property::INHERIT_POSITION;
21477   jresult = (int)result;
21478   return jresult;
21479 }
21480
21481
21482 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CLIPPING_MODE_get() {
21483   int jresult ;
21484   int result;
21485
21486   result = (int)Dali::Actor::Property::CLIPPING_MODE;
21487   jresult = (int)result;
21488   return jresult;
21489 }
21490
21491 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_OPACITY_get() {
21492
21493   return Dali::Actor::Property::OPACITY;
21494 }
21495
21496 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_SCREEN_POSITION_get() {
21497
21498   return Dali::Actor::Property::SCREEN_POSITION;
21499 }
21500
21501 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_POSITION_USES_ANCHOR_POINT_get() {
21502
21503   return Dali::Actor::Property::POSITION_USES_ANCHOR_POINT;
21504 }
21505
21506 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_INHERIT_LAYOUT_DIRECTION_get() {
21507   return Dali::Actor::Property::INHERIT_LAYOUT_DIRECTION;
21508 }
21509
21510 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_LAYOUT_DIRECTION_get() {
21511   return Dali::Actor::Property::LAYOUT_DIRECTION;
21512 }
21513
21514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor_Property() {
21515   void * jresult ;
21516   Dali::Actor::Property *result = 0 ;
21517
21518   {
21519     try {
21520       result = (Dali::Actor::Property *)new Dali::Actor::Property();
21521     } CALL_CATCH_EXCEPTION(0);
21522   }
21523
21524   jresult = (void *)result;
21525   return jresult;
21526 }
21527
21528
21529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor_Property(void * jarg1) {
21530   Dali::Actor::Property *arg1 = (Dali::Actor::Property *) 0 ;
21531
21532   arg1 = (Dali::Actor::Property *)jarg1;
21533   {
21534     try {
21535       delete arg1;
21536     } CALL_CATCH_EXCEPTION();
21537   }
21538
21539 }
21540
21541
21542 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_0() {
21543   void * jresult ;
21544   Dali::Actor *result = 0 ;
21545
21546   {
21547     try {
21548       result = (Dali::Actor *)new Dali::Actor();
21549     } CALL_CATCH_EXCEPTION(0);
21550   }
21551
21552   jresult = (void *)result;
21553   return jresult;
21554 }
21555
21556
21557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_New() {
21558   void * jresult ;
21559   Dali::Actor result;
21560
21561   {
21562     try {
21563       result = Dali::Actor::New();
21564     } CALL_CATCH_EXCEPTION(0);
21565   }
21566
21567   jresult = new Dali::Actor((const Dali::Actor &)result);
21568   return jresult;
21569 }
21570
21571
21572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_DownCast(void * jarg1) {
21573   void * jresult ;
21574   Dali::BaseHandle arg1 ;
21575   Dali::BaseHandle *argp1 ;
21576   Dali::Actor result;
21577
21578   argp1 = (Dali::BaseHandle *)jarg1;
21579   if (!argp1) {
21580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
21581     return 0;
21582   }
21583   arg1 = *argp1;
21584   {
21585     try {
21586       result = Dali::Actor::DownCast(arg1);
21587     } CALL_CATCH_EXCEPTION(0);
21588   }
21589
21590   jresult = new Dali::Actor((const Dali::Actor &)result);
21591   return jresult;
21592 }
21593
21594
21595 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor(void * jarg1) {
21596   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21597
21598   arg1 = (Dali::Actor *)jarg1;
21599   {
21600     try {
21601       delete arg1;
21602     } CALL_CATCH_EXCEPTION();
21603   }
21604
21605 }
21606
21607
21608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_1(void * jarg1) {
21609   void * jresult ;
21610   Dali::Actor *arg1 = 0 ;
21611   Dali::Actor *result = 0 ;
21612
21613   arg1 = (Dali::Actor *)jarg1;
21614   if (!arg1) {
21615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
21616     return 0;
21617   }
21618   {
21619     try {
21620       result = (Dali::Actor *)new Dali::Actor((Dali::Actor const &)*arg1);
21621     } CALL_CATCH_EXCEPTION(0);
21622   }
21623
21624   jresult = (void *)result;
21625   return jresult;
21626 }
21627
21628
21629 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_Assign(void * jarg1, void * jarg2) {
21630   void * jresult ;
21631   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21632   Dali::Actor *arg2 = 0 ;
21633   Dali::Actor *result = 0 ;
21634
21635   arg1 = (Dali::Actor *)jarg1;
21636   arg2 = (Dali::Actor *)jarg2;
21637   if (!arg2) {
21638     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
21639     return 0;
21640   }
21641   {
21642     try {
21643       result = (Dali::Actor *) &(arg1)->operator =((Dali::Actor const &)*arg2);
21644     } CALL_CATCH_EXCEPTION(0);
21645   }
21646
21647   jresult = (void *)result;
21648   return jresult;
21649 }
21650
21651
21652 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Actor_GetName(void * jarg1) {
21653   char * jresult ;
21654   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21655   std::string *result = 0 ;
21656   std::string name = "";
21657
21658   arg1 = (Dali::Actor *)jarg1;
21659   {
21660     try {
21661       name = ((Dali::Actor const *)arg1)->GetProperty< std::string >( Dali::Actor::Property::NAME );
21662       result = (std::string *) &name;
21663       jresult = SWIG_csharp_string_callback(result->c_str());
21664     } CALL_CATCH_EXCEPTION(0);
21665   }
21666   return jresult;
21667 }
21668
21669
21670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetName(void * jarg1, char * jarg2) {
21671   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21672   std::string *arg2 = 0 ;
21673
21674   arg1 = (Dali::Actor *)jarg1;
21675   if (!jarg2) {
21676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
21677     return ;
21678   }
21679   std::string arg2_str(jarg2);
21680   arg2 = &arg2_str;
21681   {
21682     try {
21683       (arg1)->SetProperty( Dali::Actor::Property::NAME, (std::string const &)*arg2);
21684     } CALL_CATCH_EXCEPTION();
21685   }
21686
21687
21688   //argout typemap for const std::string&
21689
21690 }
21691
21692
21693 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetId(void * jarg1) {
21694   unsigned int jresult ;
21695   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21696   unsigned int result;
21697
21698   arg1 = (Dali::Actor *)jarg1;
21699
21700   if(!arg1) {
21701     DALI_LOG_ERROR("[ERROR] actor is null! return -1");
21702     return -1;
21703   }
21704
21705   {
21706     try {
21707       result = (unsigned int)((Dali::Actor const *)arg1)->GetProperty< int >( Actor::Property::ID );
21708     } CALL_CATCH_EXCEPTION(0);
21709   }
21710
21711   jresult = result;
21712   return jresult;
21713 }
21714
21715
21716 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsRoot(void * jarg1) {
21717   unsigned int jresult ;
21718   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21719   bool result;
21720
21721   arg1 = (Dali::Actor *)jarg1;
21722   {
21723     try {
21724       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::IS_ROOT );
21725     } CALL_CATCH_EXCEPTION(0);
21726   }
21727
21728   jresult = result;
21729   return jresult;
21730 }
21731
21732
21733 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_OnStage(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::CONNECTED_TO_SCENE );
21742     } CALL_CATCH_EXCEPTION(0);
21743   }
21744
21745   jresult = result;
21746   return jresult;
21747 }
21748
21749
21750 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsLayer(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::IS_LAYER );
21759     } CALL_CATCH_EXCEPTION(0);
21760   }
21761
21762   jresult = result;
21763   return jresult;
21764 }
21765
21766
21767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetLayer(void * jarg1) {
21768   void * jresult ;
21769   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21770   Dali::Layer result;
21771
21772   arg1 = (Dali::Actor *)jarg1;
21773   {
21774     try {
21775       result = (arg1)->GetLayer();
21776     } CALL_CATCH_EXCEPTION(0);
21777   }
21778
21779   jresult = new Dali::Layer((const Dali::Layer &)result);
21780   return jresult;
21781 }
21782
21783
21784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Add(void * jarg1, void * jarg2) {
21785   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21786   Dali::Actor arg2 ;
21787   Dali::Actor *argp2 ;
21788
21789   arg1 = (Dali::Actor *)jarg1;
21790   argp2 = (Dali::Actor *)jarg2;
21791   if (!argp2) {
21792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
21793     return ;
21794   }
21795   arg2 = *argp2;
21796   {
21797     try {
21798       (arg1)->Add(arg2);
21799     } CALL_CATCH_EXCEPTION();
21800   }
21801
21802 }
21803
21804
21805 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Remove(void * jarg1, void * jarg2) {
21806   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21807   Dali::Actor arg2 ;
21808   Dali::Actor *argp2 ;
21809
21810   arg1 = (Dali::Actor *)jarg1;
21811   argp2 = (Dali::Actor *)jarg2;
21812   if (!argp2) {
21813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
21814     return ;
21815   }
21816   arg2 = *argp2;
21817   {
21818     try {
21819       (arg1)->Remove(arg2);
21820     } CALL_CATCH_EXCEPTION();
21821   }
21822
21823 }
21824
21825
21826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Unparent(void * jarg1) {
21827   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21828
21829   arg1 = (Dali::Actor *)jarg1;
21830   {
21831     try {
21832       (arg1)->Unparent();
21833     } CALL_CATCH_EXCEPTION();
21834   }
21835
21836 }
21837
21838
21839 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetChildCount(void * jarg1) {
21840   unsigned int jresult ;
21841   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21842   unsigned int result;
21843
21844   arg1 = (Dali::Actor *)jarg1;
21845   {
21846     try {
21847       result = (unsigned int)((Dali::Actor const *)arg1)->GetChildCount();
21848     } CALL_CATCH_EXCEPTION(0);
21849   }
21850
21851   jresult = result;
21852   return jresult;
21853 }
21854
21855
21856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetChildAt(void * jarg1, unsigned int jarg2) {
21857   void * jresult ;
21858   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21859   unsigned int arg2 ;
21860   Dali::Actor result;
21861
21862   arg1 = (Dali::Actor *)jarg1;
21863   arg2 = (unsigned int)jarg2;
21864   {
21865     try {
21866       result = ((Dali::Actor const *)arg1)->GetChildAt(arg2);
21867     } CALL_CATCH_EXCEPTION(0);
21868   }
21869
21870   jresult = new Dali::Actor((const Dali::Actor &)result);
21871   return jresult;
21872 }
21873
21874
21875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildByName(void * jarg1, char * jarg2) {
21876   void * jresult ;
21877   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21878   std::string *arg2 = 0 ;
21879   Dali::Actor result;
21880
21881   arg1 = (Dali::Actor *)jarg1;
21882   if (!jarg2) {
21883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
21884     return 0;
21885   }
21886   std::string arg2_str(jarg2);
21887   arg2 = &arg2_str;
21888   {
21889     try {
21890       result = (arg1)->FindChildByName((std::string const &)*arg2);
21891     } CALL_CATCH_EXCEPTION(0);
21892   }
21893
21894   jresult = new Dali::Actor((const Dali::Actor &)result);
21895
21896   //argout typemap for const std::string&
21897
21898   return jresult;
21899 }
21900
21901
21902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildById(void * jarg1, unsigned int jarg2) {
21903   void * jresult ;
21904   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21905   unsigned int arg2 ;
21906   Dali::Actor result;
21907
21908   arg1 = (Dali::Actor *)jarg1;
21909   arg2 = (unsigned int)jarg2;
21910   {
21911     try {
21912       result = (arg1)->FindChildById(arg2);
21913     } CALL_CATCH_EXCEPTION(0);
21914   }
21915
21916   jresult = new Dali::Actor((const Dali::Actor &)result);
21917   return jresult;
21918 }
21919
21920
21921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetParent(void * jarg1) {
21922   void * jresult ;
21923   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21924   Dali::Actor result;
21925
21926   arg1 = (Dali::Actor *)jarg1;
21927   {
21928     try {
21929       result = ((Dali::Actor const *)arg1)->GetParent();
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_SetParentOrigin(void * jarg1, void * jarg2) {
21939   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21940   Dali::Vector3 *arg2 = 0 ;
21941
21942   arg1 = (Dali::Actor *)jarg1;
21943   arg2 = (Dali::Vector3 *)jarg2;
21944   if (!arg2) {
21945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
21946     return ;
21947   }
21948   {
21949     try {
21950       (arg1)->SetProperty( Actor::Property::PARENT_ORIGIN,(Dali::Vector3 const &)*arg2);
21951     } CALL_CATCH_EXCEPTION();
21952   }
21953
21954 }
21955
21956
21957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentParentOrigin(void * jarg1) {
21958   void * jresult ;
21959   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21960   Dali::Vector3 result;
21961
21962   arg1 = (Dali::Actor *)jarg1;
21963   {
21964     try {
21965       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::PARENT_ORIGIN );
21966     } CALL_CATCH_EXCEPTION(0);
21967   }
21968
21969   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
21970   return jresult;
21971 }
21972
21973
21974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetAnchorPoint(void * jarg1, void * jarg2) {
21975   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21976   Dali::Vector3 *arg2 = 0 ;
21977
21978   arg1 = (Dali::Actor *)jarg1;
21979   arg2 = (Dali::Vector3 *)jarg2;
21980   if (!arg2) {
21981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
21982     return ;
21983   }
21984   {
21985     try {
21986       (arg1)->SetProperty( Actor::Property::ANCHOR_POINT,(Dali::Vector3 const &)*arg2);
21987     } CALL_CATCH_EXCEPTION();
21988   }
21989
21990 }
21991
21992
21993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentAnchorPoint(void * jarg1) {
21994   void * jresult ;
21995   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
21996   Dali::Vector3 result;
21997
21998   arg1 = (Dali::Actor *)jarg1;
21999   {
22000     try {
22001       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::ANCHOR_POINT );
22002     } CALL_CATCH_EXCEPTION(0);
22003   }
22004
22005   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
22006   return jresult;
22007 }
22008
22009
22010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_0(void * jarg1, float jarg2, float jarg3) {
22011   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22012   float arg2 ;
22013   float arg3 ;
22014
22015   arg1 = (Dali::Actor *)jarg1;
22016   arg2 = (float)jarg2;
22017   arg3 = (float)jarg3;
22018   {
22019     try {
22020       (arg1)->SetProperty( Actor::Property::SIZE, Dali::Vector2(arg2,arg3) );
22021     } CALL_CATCH_EXCEPTION();
22022   }
22023
22024 }
22025
22026
22027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
22028   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22029   float arg2 ;
22030   float arg3 ;
22031   float arg4 ;
22032
22033   arg1 = (Dali::Actor *)jarg1;
22034   arg2 = (float)jarg2;
22035   arg3 = (float)jarg3;
22036   arg4 = (float)jarg4;
22037   {
22038     try {
22039       (arg1)->SetProperty( Actor::Property::SIZE, Dali::Vector3(arg2,arg3,arg4) );
22040     } CALL_CATCH_EXCEPTION();
22041   }
22042
22043 }
22044
22045
22046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_2(void * jarg1, void * jarg2) {
22047   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22048   Dali::Vector2 *arg2 = 0 ;
22049
22050   arg1 = (Dali::Actor *)jarg1;
22051   arg2 = (Dali::Vector2 *)jarg2;
22052   if (!arg2) {
22053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
22054     return ;
22055   }
22056   {
22057     try {
22058       (arg1)->SetProperty( Actor::Property::SIZE, (Dali::Vector2 const &)*arg2);
22059     } CALL_CATCH_EXCEPTION();
22060   }
22061
22062 }
22063
22064
22065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_3(void * jarg1, void * jarg2) {
22066   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22067   Dali::Vector3 *arg2 = 0 ;
22068
22069   arg1 = (Dali::Actor *)jarg1;
22070   arg2 = (Dali::Vector3 *)jarg2;
22071   if (!arg2) {
22072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
22073     return ;
22074   }
22075   {
22076     try {
22077       (arg1)->SetProperty( Actor::Property::SIZE, (Dali::Vector3 const &)*arg2);
22078     } CALL_CATCH_EXCEPTION();
22079   }
22080
22081 }
22082
22083
22084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetTargetSize(void * jarg1) {
22085   void * jresult ;
22086   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22087   Dali::Vector3 result;
22088
22089   arg1 = (Dali::Actor *)jarg1;
22090   {
22091     try {
22092       result = ((Dali::Actor const *)arg1)->GetTargetSize();
22093     } CALL_CATCH_EXCEPTION(0);
22094   }
22095
22096   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
22097   return jresult;
22098 }
22099
22100
22101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentSize(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)->GetCurrentProperty< Vector3 >( Actor::Property::SIZE );
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_GetNaturalSize(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)->GetNaturalSize();
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_SetPosition__SWIG_0(void * jarg1, float jarg2, float jarg3) {
22136   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22137   float arg2 ;
22138   float arg3 ;
22139
22140   arg1 = (Dali::Actor *)jarg1;
22141   arg2 = (float)jarg2;
22142   arg3 = (float)jarg3;
22143   {
22144     try {
22145       (arg1)->SetProperty( Actor::Property::POSITION, Dali::Vector2( arg2, arg3 ) );
22146     } CALL_CATCH_EXCEPTION();
22147   }
22148
22149 }
22150
22151
22152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
22153   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22154   float arg2 ;
22155   float arg3 ;
22156   float arg4 ;
22157
22158   arg1 = (Dali::Actor *)jarg1;
22159   arg2 = (float)jarg2;
22160   arg3 = (float)jarg3;
22161   arg4 = (float)jarg4;
22162   {
22163     try {
22164       (arg1)->SetProperty( Actor::Property::POSITION, Dali::Vector3( arg2, arg3, arg4 ) );
22165     } CALL_CATCH_EXCEPTION();
22166   }
22167
22168 }
22169
22170
22171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_2(void * jarg1, void * jarg2) {
22172   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22173   Dali::Vector3 *arg2 = 0 ;
22174
22175   arg1 = (Dali::Actor *)jarg1;
22176   arg2 = (Dali::Vector3 *)jarg2;
22177   if (!arg2) {
22178     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
22179     return ;
22180   }
22181   {
22182     try {
22183       (arg1)->SetProperty( Actor::Property::POSITION, (Dali::Vector3 const &)*arg2 );
22184     } CALL_CATCH_EXCEPTION();
22185   }
22186
22187 }
22188
22189
22190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetX(void * jarg1, float jarg2) {
22191   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22192   float arg2 ;
22193
22194   arg1 = (Dali::Actor *)jarg1;
22195   arg2 = (float)jarg2;
22196   {
22197     try {
22198       (arg1)->SetProperty( Actor::Property::POSITION_X, (arg2) );
22199     } CALL_CATCH_EXCEPTION();
22200   }
22201
22202 }
22203
22204
22205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetY(void * jarg1, float jarg2) {
22206   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22207   float arg2 ;
22208
22209   arg1 = (Dali::Actor *)jarg1;
22210   arg2 = (float)jarg2;
22211   {
22212     try {
22213       (arg1)->SetProperty( Actor::Property::POSITION_Y, arg2 );
22214     } CALL_CATCH_EXCEPTION();
22215   }
22216
22217 }
22218
22219
22220 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetZ(void * jarg1, float jarg2) {
22221   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22222   float arg2 ;
22223
22224   arg1 = (Dali::Actor *)jarg1;
22225   arg2 = (float)jarg2;
22226   {
22227     try {
22228       (arg1)->SetProperty( Actor::Property::POSITION_Z, arg2 );
22229     } CALL_CATCH_EXCEPTION();
22230   }
22231
22232 }
22233
22234
22235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_TranslateBy(void * jarg1, void * jarg2) {
22236   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22237   Dali::Vector3 *arg2 = 0 ;
22238
22239   arg1 = (Dali::Actor *)jarg1;
22240   arg2 = (Dali::Vector3 *)jarg2;
22241   if (!arg2) {
22242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
22243     return ;
22244   }
22245   {
22246     try {
22247       (arg1)->TranslateBy((Dali::Vector3 const &)*arg2);
22248     } CALL_CATCH_EXCEPTION();
22249   }
22250
22251 }
22252
22253
22254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentPosition(void * jarg1) {
22255   void * jresult ;
22256   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22257   Dali::Vector3 result;
22258
22259   arg1 = (Dali::Actor *)jarg1;
22260   {
22261     try {
22262       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::POSITION );
22263     } CALL_CATCH_EXCEPTION(0);
22264   }
22265
22266   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
22267   return jresult;
22268 }
22269
22270
22271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldPosition(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::WORLD_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_SetInheritPosition(void * jarg1, unsigned int jarg2) {
22289   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22290   bool arg2 ;
22291
22292   arg1 = (Dali::Actor *)jarg1;
22293   arg2 = jarg2 ? true : false;
22294   {
22295     try {
22296       (arg1)->SetProperty(Dali::Actor::Property::INHERIT_POSITION, arg2);
22297     } CALL_CATCH_EXCEPTION();
22298   }
22299
22300 }
22301
22302
22303 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsPositionInherited(void * jarg1) {
22304   unsigned int jresult ;
22305   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22306   bool result;
22307
22308   arg1 = (Dali::Actor *)jarg1;
22309   {
22310     try {
22311       result = (bool)((Dali::Actor const *)arg1)->GetProperty<bool>(Dali::Actor::Property::INHERIT_POSITION);
22312     } CALL_CATCH_EXCEPTION(0);
22313   }
22314
22315   jresult = result;
22316   return jresult;
22317 }
22318
22319
22320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
22321   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22322   Dali::Degree *arg2 = 0 ;
22323   Dali::Vector3 *arg3 = 0 ;
22324
22325   arg1 = (Dali::Actor *)jarg1;
22326   arg2 = (Dali::Degree *)jarg2;
22327   if (!arg2) {
22328     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
22329     return ;
22330   }
22331   arg3 = (Dali::Vector3 *)jarg3;
22332   if (!arg3) {
22333     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
22334     return ;
22335   }
22336   {
22337     try {
22338       (arg1)->SetProperty( Actor::Property::ORIENTATION, Quaternion( (Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3 ) );
22339     } CALL_CATCH_EXCEPTION();
22340   }
22341
22342 }
22343
22344
22345 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
22346   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22347   Dali::Radian *arg2 = 0 ;
22348   Dali::Vector3 *arg3 = 0 ;
22349
22350   arg1 = (Dali::Actor *)jarg1;
22351   arg2 = (Dali::Radian *)jarg2;
22352   if (!arg2) {
22353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
22354     return ;
22355   }
22356   arg3 = (Dali::Vector3 *)jarg3;
22357   if (!arg3) {
22358     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
22359     return ;
22360   }
22361   {
22362     try {
22363       (arg1)->SetProperty( Actor::Property::ORIENTATION, Quaternion( (Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3 ) );
22364     } CALL_CATCH_EXCEPTION();
22365   }
22366
22367 }
22368
22369
22370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_2(void * jarg1, void * jarg2) {
22371   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22372   Dali::Quaternion *arg2 = 0 ;
22373
22374   arg1 = (Dali::Actor *)jarg1;
22375   arg2 = (Dali::Quaternion *)jarg2;
22376   if (!arg2) {
22377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
22378     return ;
22379   }
22380   {
22381     try {
22382       (arg1)->SetProperty( Actor::Property::ORIENTATION, (Dali::Quaternion const &)*arg2 );
22383     } CALL_CATCH_EXCEPTION();
22384   }
22385
22386 }
22387
22388
22389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
22390   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22391   Dali::Degree *arg2 = 0 ;
22392   Dali::Vector3 *arg3 = 0 ;
22393
22394   arg1 = (Dali::Actor *)jarg1;
22395   arg2 = (Dali::Degree *)jarg2;
22396   if (!arg2) {
22397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
22398     return ;
22399   }
22400   arg3 = (Dali::Vector3 *)jarg3;
22401   if (!arg3) {
22402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
22403     return ;
22404   }
22405   {
22406     try {
22407       (arg1)->RotateBy((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
22408     } CALL_CATCH_EXCEPTION();
22409   }
22410
22411 }
22412
22413
22414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
22415   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22416   Dali::Radian *arg2 = 0 ;
22417   Dali::Vector3 *arg3 = 0 ;
22418
22419   arg1 = (Dali::Actor *)jarg1;
22420   arg2 = (Dali::Radian *)jarg2;
22421   if (!arg2) {
22422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
22423     return ;
22424   }
22425   arg3 = (Dali::Vector3 *)jarg3;
22426   if (!arg3) {
22427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
22428     return ;
22429   }
22430   {
22431     try {
22432       (arg1)->RotateBy((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
22433     } CALL_CATCH_EXCEPTION();
22434   }
22435
22436 }
22437
22438
22439 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_2(void * jarg1, void * jarg2) {
22440   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22441   Dali::Quaternion *arg2 = 0 ;
22442
22443   arg1 = (Dali::Actor *)jarg1;
22444   arg2 = (Dali::Quaternion *)jarg2;
22445   if (!arg2) {
22446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
22447     return ;
22448   }
22449   {
22450     try {
22451       (arg1)->RotateBy((Dali::Quaternion const &)*arg2);
22452     } CALL_CATCH_EXCEPTION();
22453   }
22454
22455 }
22456
22457
22458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOrientation(void * jarg1) {
22459   void * jresult ;
22460   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22461   Dali::Quaternion result;
22462
22463   arg1 = (Dali::Actor *)jarg1;
22464   {
22465     try {
22466       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION );
22467     } CALL_CATCH_EXCEPTION(0);
22468   }
22469
22470   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
22471   return jresult;
22472 }
22473
22474
22475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritOrientation(void * jarg1, unsigned int jarg2) {
22476   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22477   bool arg2 ;
22478
22479   arg1 = (Dali::Actor *)jarg1;
22480   arg2 = jarg2 ? true : false;
22481   {
22482     try {
22483       (arg1)->SetProperty( Actor::Property::INHERIT_ORIENTATION,arg2);
22484     } CALL_CATCH_EXCEPTION();
22485   }
22486
22487 }
22488
22489
22490 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsOrientationInherited(void * jarg1) {
22491   unsigned int jresult ;
22492   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22493   bool result;
22494
22495   arg1 = (Dali::Actor *)jarg1;
22496   {
22497     try {
22498       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::INHERIT_ORIENTATION );
22499     } CALL_CATCH_EXCEPTION(0);
22500   }
22501
22502   jresult = result;
22503   return jresult;
22504 }
22505
22506
22507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldOrientation(void * jarg1) {
22508   void * jresult ;
22509   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22510   Dali::Quaternion result;
22511
22512   arg1 = (Dali::Actor *)jarg1;
22513   {
22514     try {
22515       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Quaternion >( Actor::Property::WORLD_ORIENTATION );
22516     } CALL_CATCH_EXCEPTION(0);
22517   }
22518
22519   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
22520   return jresult;
22521 }
22522
22523
22524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_0(void * jarg1, float jarg2) {
22525   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22526   float arg2 ;
22527
22528   arg1 = (Dali::Actor *)jarg1;
22529   arg2 = (float)jarg2;
22530   {
22531     try {
22532       (arg1)->SetProperty( Actor::Property::SCALE, arg2);
22533     } CALL_CATCH_EXCEPTION();
22534   }
22535
22536 }
22537
22538
22539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
22540   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22541   float arg2 ;
22542   float arg3 ;
22543   float arg4 ;
22544
22545   arg1 = (Dali::Actor *)jarg1;
22546   arg2 = (float)jarg2;
22547   arg3 = (float)jarg3;
22548   arg4 = (float)jarg4;
22549   {
22550     try {
22551       (arg1)->SetProperty( Actor::Property::SCALE, Vector3( arg2, arg3, arg4 ) );
22552     } CALL_CATCH_EXCEPTION();
22553   }
22554
22555 }
22556
22557
22558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_2(void * jarg1, void * jarg2) {
22559   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22560   Dali::Vector3 *arg2 = 0 ;
22561
22562   arg1 = (Dali::Actor *)jarg1;
22563   arg2 = (Dali::Vector3 *)jarg2;
22564   if (!arg2) {
22565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
22566     return ;
22567   }
22568   {
22569     try {
22570       (arg1)->SetProperty( Actor::Property::SCALE, (Dali::Vector3 const &)*arg2 );
22571     } CALL_CATCH_EXCEPTION();
22572   }
22573
22574 }
22575
22576
22577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_ScaleBy(void * jarg1, void * jarg2) {
22578   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22579   Dali::Vector3 *arg2 = 0 ;
22580
22581   arg1 = (Dali::Actor *)jarg1;
22582   arg2 = (Dali::Vector3 *)jarg2;
22583   if (!arg2) {
22584     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
22585     return ;
22586   }
22587   {
22588     try {
22589       (arg1)->ScaleBy((Dali::Vector3 const &)*arg2);
22590     } CALL_CATCH_EXCEPTION();
22591   }
22592
22593 }
22594
22595
22596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentScale(void * jarg1) {
22597   void * jresult ;
22598   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22599   Dali::Vector3 result;
22600
22601   arg1 = (Dali::Actor *)jarg1;
22602   {
22603     try {
22604       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::SCALE );
22605     } CALL_CATCH_EXCEPTION(0);
22606   }
22607
22608   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
22609   return jresult;
22610 }
22611
22612
22613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldScale(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::WORLD_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_SetInheritScale(void * jarg1, unsigned int jarg2) {
22631   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22632   bool arg2 ;
22633
22634   arg1 = (Dali::Actor *)jarg1;
22635   arg2 = jarg2 ? true : false;
22636   {
22637     try {
22638       (arg1)->SetProperty( Actor::Property::INHERIT_SCALE,arg2);
22639     } CALL_CATCH_EXCEPTION();
22640   }
22641
22642 }
22643
22644
22645 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsScaleInherited(void * jarg1) {
22646   unsigned int jresult ;
22647   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22648   bool result;
22649
22650   arg1 = (Dali::Actor *)jarg1;
22651   {
22652     try {
22653       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::INHERIT_SCALE );
22654     } CALL_CATCH_EXCEPTION(0);
22655   }
22656
22657   jresult = result;
22658   return jresult;
22659 }
22660
22661
22662 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldMatrix(void * jarg1) {
22663   void * jresult ;
22664   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22665   Dali::Matrix result;
22666
22667   arg1 = (Dali::Actor *)jarg1;
22668   {
22669     try {
22670       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Matrix >( Actor::Property::WORLD_MATRIX );
22671     } CALL_CATCH_EXCEPTION(0);
22672   }
22673
22674   jresult = new Dali::Matrix((const Dali::Matrix &)result);
22675   return jresult;
22676 }
22677
22678
22679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetVisible(void * jarg1, unsigned int jarg2) {
22680   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22681   bool arg2 ;
22682
22683   arg1 = (Dali::Actor *)jarg1;
22684   arg2 = jarg2 ? true : false;
22685   {
22686     try {
22687       (arg1)->SetProperty( Actor::Property::VISIBLE,arg2);
22688     } CALL_CATCH_EXCEPTION();
22689   }
22690
22691 }
22692
22693
22694 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsVisible(void * jarg1) {
22695   unsigned int jresult ;
22696   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22697   bool result;
22698
22699   arg1 = (Dali::Actor *)jarg1;
22700   {
22701     try {
22702       result = (bool)((Dali::Actor const *)arg1)->GetCurrentProperty< bool >( Actor::Property::VISIBLE );
22703     } CALL_CATCH_EXCEPTION(0);
22704   }
22705
22706   jresult = result;
22707   return jresult;
22708 }
22709
22710
22711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOpacity(void * jarg1, float jarg2) {
22712   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22713   float arg2 ;
22714
22715   arg1 = (Dali::Actor *)jarg1;
22716   arg2 = (float)jarg2;
22717   {
22718     try {
22719       (arg1)->SetProperty( Actor::Property::OPACITY,arg2);
22720     } CALL_CATCH_EXCEPTION();
22721   }
22722
22723 }
22724
22725
22726 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOpacity(void * jarg1) {
22727   float jresult ;
22728   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22729   float result;
22730
22731   arg1 = (Dali::Actor *)jarg1;
22732   {
22733     try {
22734       result = (float)((Dali::Actor const *)arg1)->GetCurrentProperty< float >( Actor::Property::OPACITY );
22735     } CALL_CATCH_EXCEPTION(0);
22736   }
22737
22738   jresult = result;
22739   return jresult;
22740 }
22741
22742
22743 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColor(void * jarg1, void * jarg2) {
22744   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22745   Dali::Vector4 *arg2 = 0 ;
22746
22747   arg1 = (Dali::Actor *)jarg1;
22748   arg2 = (Dali::Vector4 *)jarg2;
22749   if (!arg2) {
22750     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
22751     return ;
22752   }
22753   {
22754     try {
22755       (arg1)->SetProperty( Actor::Property::COLOR,(Dali::Vector4 const &)*arg2);
22756     } CALL_CATCH_EXCEPTION();
22757   }
22758
22759 }
22760
22761
22762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentColor(void * jarg1) {
22763   void * jresult ;
22764   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22765   Dali::Vector4 result;
22766
22767   arg1 = (Dali::Actor *)jarg1;
22768   {
22769     try {
22770       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector4 >( Actor::Property::COLOR );
22771     } CALL_CATCH_EXCEPTION(0);
22772   }
22773
22774   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
22775   return jresult;
22776 }
22777
22778
22779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColorMode(void * jarg1, int jarg2) {
22780   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22781   Dali::ColorMode arg2 ;
22782
22783   arg1 = (Dali::Actor *)jarg1;
22784   arg2 = (Dali::ColorMode)jarg2;
22785   {
22786     try {
22787       (arg1)->SetProperty( Actor::Property::COLOR_MODE,arg2);
22788     } CALL_CATCH_EXCEPTION();
22789   }
22790
22791 }
22792
22793
22794 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetColorMode(void * jarg1) {
22795   int jresult ;
22796   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22797   Dali::ColorMode result;
22798
22799   arg1 = (Dali::Actor *)jarg1;
22800   {
22801     try {
22802       result = (Dali::ColorMode)((Dali::Actor const *)arg1)->GetProperty< ColorMode >( Actor::Property::COLOR_MODE );
22803     } CALL_CATCH_EXCEPTION(0);
22804   }
22805
22806   jresult = (int)result;
22807   return jresult;
22808 }
22809
22810
22811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldColor(void * jarg1) {
22812   void * jresult ;
22813   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22814   Dali::Vector4 result;
22815
22816   arg1 = (Dali::Actor *)jarg1;
22817   {
22818     try {
22819       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector4 >( Actor::Property::WORLD_COLOR );
22820     } CALL_CATCH_EXCEPTION(0);
22821   }
22822
22823   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
22824   return jresult;
22825 }
22826
22827
22828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetDrawMode(void * jarg1, int jarg2) {
22829   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22830   Dali::DrawMode::Type arg2 ;
22831
22832   arg1 = (Dali::Actor *)jarg1;
22833   arg2 = (Dali::DrawMode::Type)jarg2;
22834   {
22835     try {
22836       (arg1)->SetProperty( Actor::Property::DRAW_MODE,arg2);
22837     } CALL_CATCH_EXCEPTION();
22838   }
22839
22840 }
22841
22842
22843 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetDrawMode(void * jarg1) {
22844   int jresult ;
22845   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22846   Dali::DrawMode::Type result;
22847
22848   arg1 = (Dali::Actor *)jarg1;
22849   {
22850     try {
22851       result = (Dali::DrawMode::Type)((Dali::Actor const *)arg1)->GetProperty< DrawMode::Type >( Actor::Property::DRAW_MODE );
22852     } CALL_CATCH_EXCEPTION(0);
22853   }
22854
22855   jresult = (int)result;
22856   return jresult;
22857 }
22858
22859
22860 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSensitive(void * jarg1, unsigned int jarg2) {
22861   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22862   bool arg2 ;
22863
22864   arg1 = (Dali::Actor *)jarg1;
22865   arg2 = jarg2 ? true : false;
22866   {
22867     try {
22868       (arg1)->SetProperty( Actor::Property::SENSITIVE,arg2);
22869     } CALL_CATCH_EXCEPTION();
22870   }
22871
22872 }
22873
22874
22875 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsSensitive(void * jarg1) {
22876   unsigned int jresult ;
22877   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22878   bool result;
22879
22880   arg1 = (Dali::Actor *)jarg1;
22881   {
22882     try {
22883       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::SENSITIVE );
22884     } CALL_CATCH_EXCEPTION(0);
22885   }
22886
22887   jresult = result;
22888   return jresult;
22889 }
22890
22891
22892 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_ScreenToLocal(void * jarg1, float * jarg2, float * jarg3, float jarg4, float jarg5) {
22893   unsigned int jresult ;
22894   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22895   float *arg2 = 0 ;
22896   float *arg3 = 0 ;
22897   float arg4 ;
22898   float arg5 ;
22899   bool result;
22900
22901   arg1 = (Dali::Actor *)jarg1;
22902   arg2 = (float *)jarg2;
22903   arg3 = (float *)jarg3;
22904   arg4 = (float)jarg4;
22905   arg5 = (float)jarg5;
22906   {
22907     try {
22908       result = (bool)((Dali::Actor const *)arg1)->ScreenToLocal(*arg2,*arg3,arg4,arg5);
22909     } CALL_CATCH_EXCEPTION(0);
22910   }
22911
22912   jresult = result;
22913   return jresult;
22914 }
22915
22916
22917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetLeaveRequired(void * jarg1, unsigned int jarg2) {
22918   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22919   bool arg2 ;
22920
22921   arg1 = (Dali::Actor *)jarg1;
22922   arg2 = jarg2 ? true : false;
22923   {
22924     try {
22925       (arg1)->SetProperty( Actor::Property::LEAVE_REQUIRED,arg2);
22926     } CALL_CATCH_EXCEPTION();
22927   }
22928
22929 }
22930
22931
22932 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetLeaveRequired(void * jarg1) {
22933   unsigned int jresult ;
22934   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22935   bool result;
22936
22937   arg1 = (Dali::Actor *)jarg1;
22938   {
22939     try {
22940       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::LEAVE_REQUIRED );
22941     } CALL_CATCH_EXCEPTION(0);
22942   }
22943
22944   jresult = result;
22945   return jresult;
22946 }
22947
22948
22949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusable(void * jarg1, unsigned int jarg2) {
22950   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22951   bool arg2 ;
22952
22953   arg1 = (Dali::Actor *)jarg1;
22954   arg2 = jarg2 ? true : false;
22955   {
22956     try {
22957       (arg1)->SetProperty( Actor::Property::KEYBOARD_FOCUSABLE, arg2 );
22958     } CALL_CATCH_EXCEPTION();
22959   }
22960
22961 }
22962
22963
22964 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsKeyboardFocusable(void * jarg1) {
22965   unsigned int jresult ;
22966   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22967   bool result;
22968
22969   arg1 = (Dali::Actor *)jarg1;
22970   {
22971     try {
22972       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::KEYBOARD_FOCUSABLE );
22973     } CALL_CATCH_EXCEPTION(0);
22974   }
22975
22976   jresult = result;
22977   return jresult;
22978 }
22979
22980
22981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetResizePolicy(void * jarg1, int jarg2, int jarg3) {
22982   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
22983   Dali::ResizePolicy::Type arg2 ;
22984   Dali::Dimension::Type arg3 ;
22985
22986   arg1 = (Dali::Actor *)jarg1;
22987   arg2 = (Dali::ResizePolicy::Type)jarg2;
22988   arg3 = (Dali::Dimension::Type)jarg3;
22989   {
22990     try {
22991       (arg1)->SetResizePolicy(arg2,arg3);
22992     } CALL_CATCH_EXCEPTION();
22993   }
22994
22995 }
22996
22997
22998 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetResizePolicy(void * jarg1, int jarg2) {
22999   int jresult ;
23000   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23001   Dali::Dimension::Type arg2 ;
23002   Dali::ResizePolicy::Type result;
23003
23004   arg1 = (Dali::Actor *)jarg1;
23005   arg2 = (Dali::Dimension::Type)jarg2;
23006   {
23007     try {
23008       result = (Dali::ResizePolicy::Type)((Dali::Actor const *)arg1)->GetResizePolicy(arg2);
23009     } CALL_CATCH_EXCEPTION(0);
23010   }
23011
23012   jresult = (int)result;
23013   return jresult;
23014 }
23015
23016
23017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeScalePolicy(void * jarg1, int jarg2) {
23018   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23019   Dali::SizeScalePolicy::Type arg2 ;
23020
23021   arg1 = (Dali::Actor *)jarg1;
23022   arg2 = (Dali::SizeScalePolicy::Type)jarg2;
23023   {
23024     try {
23025       (arg1)->SetProperty( Actor::Property::SIZE_SCALE_POLICY,arg2);
23026     } CALL_CATCH_EXCEPTION();
23027   }
23028
23029 }
23030
23031
23032 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetSizeScalePolicy(void * jarg1) {
23033   int jresult ;
23034   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23035   Dali::SizeScalePolicy::Type result;
23036
23037   arg1 = (Dali::Actor *)jarg1;
23038   {
23039     try {
23040       result = (Dali::SizeScalePolicy::Type)((Dali::Actor const *)arg1)->GetProperty< SizeScalePolicy::Type >( Actor::Property::SIZE_SCALE_POLICY );
23041     } CALL_CATCH_EXCEPTION(0);
23042   }
23043
23044   jresult = (int)result;
23045   return jresult;
23046 }
23047
23048
23049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeModeFactor(void * jarg1, void * jarg2) {
23050   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23051   Dali::Vector3 *arg2 = 0 ;
23052
23053   arg1 = (Dali::Actor *)jarg1;
23054   arg2 = (Dali::Vector3 *)jarg2;
23055   if (!arg2) {
23056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
23057     return ;
23058   }
23059   {
23060     try {
23061       (arg1)->SetProperty( Actor::Property::SIZE_MODE_FACTOR, (Dali::Vector3 const &)*arg2);
23062     } CALL_CATCH_EXCEPTION();
23063   }
23064
23065 }
23066
23067
23068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetSizeModeFactor(void * jarg1) {
23069   void * jresult ;
23070   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23071   Dali::Vector3 result;
23072
23073   arg1 = (Dali::Actor *)jarg1;
23074   {
23075     try {
23076       result = ((Dali::Actor const *)arg1)->GetProperty< Vector3 >( Actor::Property::SIZE_MODE_FACTOR );
23077     } CALL_CATCH_EXCEPTION(0);
23078   }
23079
23080   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
23081   return jresult;
23082 }
23083
23084
23085 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetHeightForWidth(void * jarg1, float jarg2) {
23086   float jresult ;
23087   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23088   float arg2 ;
23089   float result;
23090
23091   arg1 = (Dali::Actor *)jarg1;
23092   arg2 = (float)jarg2;
23093   {
23094     try {
23095       result = (float)(arg1)->GetHeightForWidth(arg2);
23096     } CALL_CATCH_EXCEPTION(0);
23097   }
23098
23099   jresult = result;
23100   return jresult;
23101 }
23102
23103
23104 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetWidthForHeight(void * jarg1, float jarg2) {
23105   float jresult ;
23106   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23107   float arg2 ;
23108   float result;
23109
23110   arg1 = (Dali::Actor *)jarg1;
23111   arg2 = (float)jarg2;
23112   {
23113     try {
23114       result = (float)(arg1)->GetWidthForHeight(arg2);
23115     } CALL_CATCH_EXCEPTION(0);
23116   }
23117
23118   jresult = result;
23119   return jresult;
23120 }
23121
23122
23123 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetRelayoutSize(void * jarg1, int jarg2) {
23124   float jresult ;
23125   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23126   Dali::Dimension::Type arg2 ;
23127   float result;
23128
23129   arg1 = (Dali::Actor *)jarg1;
23130   arg2 = (Dali::Dimension::Type)jarg2;
23131   {
23132     try {
23133       result = (float)((Dali::Actor const *)arg1)->GetRelayoutSize(arg2);
23134     } CALL_CATCH_EXCEPTION(0);
23135   }
23136
23137   jresult = result;
23138   return jresult;
23139 }
23140
23141
23142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPadding(void * jarg1, void * jarg2) {
23143   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23144   Dali::Padding *arg2 = 0 ;
23145
23146   arg1 = (Dali::Actor *)jarg1;
23147   arg2 = (Dali::Padding *)jarg2;
23148   if (!arg2) {
23149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding const & type is null", 0);
23150     return ;
23151   }
23152   {
23153     try {
23154       (arg1)->SetProperty( Actor::Property::PADDING, (Dali::Padding const &)*arg2);
23155     } CALL_CATCH_EXCEPTION();
23156   }
23157
23158 }
23159
23160
23161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_GetPadding(void * jarg1, void * jarg2) {
23162   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23163   Dali::Padding *arg2 = 0 ;
23164
23165   arg1 = (Dali::Actor *)jarg1;
23166   arg2 = (Dali::Padding *)jarg2;
23167   if (!arg2) {
23168     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding & type is null", 0);
23169     return ;
23170   }
23171   {
23172     try {
23173       *arg2 = ((Dali::Actor const *)arg1)->GetProperty<Vector4>( Actor::Property::PADDING );
23174     } CALL_CATCH_EXCEPTION();
23175   }
23176
23177 }
23178
23179
23180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMinimumSize(void * jarg1, void * jarg2) {
23181   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23182   Dali::Vector2 *arg2 = 0 ;
23183
23184   arg1 = (Dali::Actor *)jarg1;
23185   arg2 = (Dali::Vector2 *)jarg2;
23186   if (!arg2) {
23187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
23188     return ;
23189   }
23190   {
23191     try {
23192       (arg1)->SetProperty( Actor::Property::MINIMUM_SIZE,(Dali::Vector2 const &)*arg2);
23193     } CALL_CATCH_EXCEPTION();
23194   }
23195
23196 }
23197
23198
23199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMinimumSize(void * jarg1) {
23200   void * jresult ;
23201   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23202   Dali::Vector2 result;
23203
23204   arg1 = (Dali::Actor *)jarg1;
23205   {
23206     try {
23207       result = (arg1)->GetProperty< Vector2 >( Actor::Property::MINIMUM_SIZE );
23208     } CALL_CATCH_EXCEPTION(0);
23209   }
23210
23211   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
23212   return jresult;
23213 }
23214
23215
23216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMaximumSize(void * jarg1, void * jarg2) {
23217   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23218   Dali::Vector2 *arg2 = 0 ;
23219
23220   arg1 = (Dali::Actor *)jarg1;
23221   arg2 = (Dali::Vector2 *)jarg2;
23222   if (!arg2) {
23223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
23224     return ;
23225   }
23226   {
23227     try {
23228       (arg1)->SetProperty( Actor::Property::MAXIMUM_SIZE,(Dali::Vector2 const &)*arg2);
23229     } CALL_CATCH_EXCEPTION();
23230   }
23231
23232 }
23233
23234
23235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMaximumSize(void * jarg1) {
23236   void * jresult ;
23237   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23238   Dali::Vector2 result;
23239
23240   arg1 = (Dali::Actor *)jarg1;
23241   {
23242     try {
23243       result = (arg1)->GetProperty< Vector2 >( Actor::Property::MAXIMUM_SIZE );
23244     } CALL_CATCH_EXCEPTION(0);
23245   }
23246
23247   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
23248   return jresult;
23249 }
23250
23251
23252 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetHierarchyDepth(void * jarg1) {
23253   int jresult ;
23254   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23255   int result;
23256
23257   arg1 = (Dali::Actor *)jarg1;
23258   {
23259     try {
23260       result = (int)(arg1)->GetProperty< int >( Actor::Property::HIERARCHY_DEPTH );
23261       Dali::Actor parent = ((Dali::Actor const *)arg1)->GetParent();
23262     } CALL_CATCH_EXCEPTION(0);
23263   }
23264
23265   jresult = result;
23266   return jresult;
23267 }
23268
23269
23270 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_AddRenderer(void * jarg1, void * jarg2) {
23271   unsigned int jresult ;
23272   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23273   Dali::Renderer *arg2 = 0 ;
23274   unsigned int result;
23275
23276   arg1 = (Dali::Actor *)jarg1;
23277   arg2 = (Dali::Renderer *)jarg2;
23278   if (!arg2) {
23279     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
23280     return 0;
23281   }
23282   {
23283     try {
23284       result = (unsigned int)(arg1)->AddRenderer(*arg2);
23285     } CALL_CATCH_EXCEPTION(0);
23286   }
23287
23288   jresult = result;
23289   return jresult;
23290 }
23291
23292
23293 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetRendererCount(void * jarg1) {
23294   unsigned int jresult ;
23295   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23296   unsigned int result;
23297
23298   arg1 = (Dali::Actor *)jarg1;
23299   {
23300     try {
23301       result = (unsigned int)((Dali::Actor const *)arg1)->GetRendererCount();
23302     } CALL_CATCH_EXCEPTION(0);
23303   }
23304
23305   jresult = result;
23306   return jresult;
23307 }
23308
23309
23310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetRendererAt(void * jarg1, unsigned int jarg2) {
23311   void * jresult ;
23312   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23313   unsigned int arg2 ;
23314   Dali::Renderer result;
23315
23316   arg1 = (Dali::Actor *)jarg1;
23317   arg2 = (unsigned int)jarg2;
23318   {
23319     try {
23320       result = (arg1)->GetRendererAt(arg2);
23321     } CALL_CATCH_EXCEPTION(0);
23322   }
23323
23324   jresult = new Dali::Renderer((const Dali::Renderer &)result);
23325   return jresult;
23326 }
23327
23328
23329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_0(void * jarg1, void * jarg2) {
23330   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23331   Dali::Renderer *arg2 = 0 ;
23332
23333   arg1 = (Dali::Actor *)jarg1;
23334   arg2 = (Dali::Renderer *)jarg2;
23335   if (!arg2) {
23336     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
23337     return ;
23338   }
23339   {
23340     try {
23341       (arg1)->RemoveRenderer(*arg2);
23342     } CALL_CATCH_EXCEPTION();
23343   }
23344
23345 }
23346
23347
23348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_1(void * jarg1, unsigned int jarg2) {
23349   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23350   unsigned int arg2 ;
23351
23352   arg1 = (Dali::Actor *)jarg1;
23353   arg2 = (unsigned int)jarg2;
23354   {
23355     try {
23356       (arg1)->RemoveRenderer(arg2);
23357     } CALL_CATCH_EXCEPTION();
23358   }
23359
23360 }
23361
23362
23363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchSignal(void * jarg1) {
23364   void * jresult ;
23365   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23366   Dali::Actor::TouchEventSignalType *result = 0 ;
23367
23368   arg1 = (Dali::Actor *)jarg1;
23369   {
23370     try {
23371       result = (Dali::Actor::TouchEventSignalType *) &(arg1)->TouchSignal();
23372     } CALL_CATCH_EXCEPTION(0);
23373   }
23374
23375   jresult = (void *)result;
23376   return jresult;
23377 }
23378
23379
23380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_HoveredSignal(void * jarg1) {
23381   void * jresult ;
23382   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23383   Dali::Actor::HoverSignalType *result = 0 ;
23384
23385   arg1 = (Dali::Actor *)jarg1;
23386   {
23387     try {
23388       result = (Dali::Actor::HoverSignalType *) &(arg1)->HoveredSignal();
23389     } CALL_CATCH_EXCEPTION(0);
23390   }
23391
23392   jresult = (void *)result;
23393   return jresult;
23394 }
23395
23396
23397 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_WheelEventSignal(void * jarg1) {
23398   void * jresult ;
23399   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23400   Dali::Actor::WheelEventSignalType *result = 0 ;
23401
23402   arg1 = (Dali::Actor *)jarg1;
23403   {
23404     try {
23405       result = (Dali::Actor::WheelEventSignalType *) &(arg1)->WheelEventSignal();
23406     } CALL_CATCH_EXCEPTION(0);
23407   }
23408
23409   jresult = (void *)result;
23410   return jresult;
23411 }
23412
23413
23414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnSceneSignal(void * jarg1) {
23415   void * jresult ;
23416   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23417   Dali::Actor::OnSceneSignalType *result = 0 ;
23418
23419   arg1 = (Dali::Actor *)jarg1;
23420   {
23421     try {
23422       result = (Dali::Actor::OnSceneSignalType *) &(arg1)->OnSceneSignal();
23423     } CALL_CATCH_EXCEPTION(0);
23424   }
23425
23426   jresult = (void *)result;
23427   return jresult;
23428 }
23429
23430
23431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OffSceneSignal(void * jarg1) {
23432   void * jresult ;
23433   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23434   Dali::Actor::OffSceneSignalType *result = 0 ;
23435
23436   arg1 = (Dali::Actor *)jarg1;
23437   {
23438     try {
23439       result = (Dali::Actor::OffSceneSignalType *) &(arg1)->OffSceneSignal();
23440     } CALL_CATCH_EXCEPTION(0);
23441   }
23442
23443   jresult = (void *)result;
23444   return jresult;
23445 }
23446
23447
23448 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnRelayoutSignal(void * jarg1) {
23449   void * jresult ;
23450   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
23451   Dali::Actor::OnRelayoutSignalType *result = 0 ;
23452
23453   arg1 = (Dali::Actor *)jarg1;
23454   {
23455     try {
23456       result = (Dali::Actor::OnRelayoutSignalType *) &(arg1)->OnRelayoutSignal();
23457     } CALL_CATCH_EXCEPTION(0);
23458   }
23459
23460   jresult = (void *)result;
23461   return jresult;
23462 }
23463
23464
23465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_UnparentAndReset(void * jarg1) {
23466   Dali::Actor *arg1 = 0 ;
23467
23468   arg1 = (Dali::Actor *)jarg1;
23469   if (!arg1) {
23470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
23471     return ;
23472   }
23473   {
23474     try {
23475       Dali::UnparentAndReset(*arg1);
23476     } CALL_CATCH_EXCEPTION();
23477   }
23478
23479 }
23480
23481
23482 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_ENABLE_get() {
23483   int jresult ;
23484   int result;
23485
23486   result = (int)Dali::Layer::Property::CLIPPING_ENABLE;
23487   jresult = (int)result;
23488   return jresult;
23489 }
23490
23491
23492 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_BOX_get() {
23493   int jresult ;
23494   int result;
23495
23496   result = (int)Dali::Layer::Property::CLIPPING_BOX;
23497   jresult = (int)result;
23498   return jresult;
23499 }
23500
23501
23502 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_BEHAVIOR_get() {
23503   int jresult ;
23504   int result;
23505
23506   result = (int)Dali::Layer::Property::BEHAVIOR;
23507   jresult = (int)result;
23508   return jresult;
23509 }
23510
23511
23512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer_Property() {
23513   void * jresult ;
23514   Dali::Layer::Property *result = 0 ;
23515
23516   {
23517     try {
23518       result = (Dali::Layer::Property *)new Dali::Layer::Property();
23519     } CALL_CATCH_EXCEPTION(0);
23520   }
23521
23522   jresult = (void *)result;
23523   return jresult;
23524 }
23525
23526
23527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer_Property(void * jarg1) {
23528   Dali::Layer::Property *arg1 = (Dali::Layer::Property *) 0 ;
23529
23530   arg1 = (Dali::Layer::Property *)jarg1;
23531   {
23532     try {
23533       delete arg1;
23534     } CALL_CATCH_EXCEPTION();
23535   }
23536
23537 }
23538
23539
23540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_0() {
23541   void * jresult ;
23542   Dali::Layer *result = 0 ;
23543
23544   {
23545     try {
23546       result = (Dali::Layer *)new Dali::Layer();
23547     } CALL_CATCH_EXCEPTION(0);
23548   }
23549
23550   jresult = (void *)result;
23551   return jresult;
23552 }
23553
23554
23555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_New() {
23556   void * jresult ;
23557   Dali::Layer result;
23558
23559   {
23560     try {
23561       result = Dali::Layer::New();
23562     } CALL_CATCH_EXCEPTION(0);
23563   }
23564
23565   jresult = new Dali::Layer((const Dali::Layer &)result);
23566   return jresult;
23567 }
23568
23569
23570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_DownCast(void * jarg1) {
23571   void * jresult ;
23572   Dali::BaseHandle arg1 ;
23573   Dali::BaseHandle *argp1 ;
23574   Dali::Layer result;
23575
23576   argp1 = (Dali::BaseHandle *)jarg1;
23577   if (!argp1) {
23578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
23579     return 0;
23580   }
23581   arg1 = *argp1;
23582   {
23583     try {
23584       result = Dali::Layer::DownCast(arg1);
23585     } CALL_CATCH_EXCEPTION(0);
23586   }
23587
23588   jresult = new Dali::Layer((const Dali::Layer &)result);
23589   return jresult;
23590 }
23591
23592
23593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer(void * jarg1) {
23594   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23595
23596   arg1 = (Dali::Layer *)jarg1;
23597   {
23598     try {
23599       delete arg1;
23600     } CALL_CATCH_EXCEPTION();
23601   }
23602
23603 }
23604
23605
23606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_1(void * jarg1) {
23607   void * jresult ;
23608   Dali::Layer *arg1 = 0 ;
23609   Dali::Layer *result = 0 ;
23610
23611   arg1 = (Dali::Layer *)jarg1;
23612   if (!arg1) {
23613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
23614     return 0;
23615   }
23616   {
23617     try {
23618       result = (Dali::Layer *)new Dali::Layer((Dali::Layer const &)*arg1);
23619     } CALL_CATCH_EXCEPTION(0);
23620   }
23621
23622   jresult = (void *)result;
23623   return jresult;
23624 }
23625
23626
23627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_Assign(void * jarg1, void * jarg2) {
23628   void * jresult ;
23629   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23630   Dali::Layer *arg2 = 0 ;
23631   Dali::Layer *result = 0 ;
23632
23633   arg1 = (Dali::Layer *)jarg1;
23634   arg2 = (Dali::Layer *)jarg2;
23635   if (!arg2) {
23636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
23637     return 0;
23638   }
23639   {
23640     try {
23641       result = (Dali::Layer *) &(arg1)->operator =((Dali::Layer const &)*arg2);
23642     } CALL_CATCH_EXCEPTION(0);
23643   }
23644
23645   jresult = (void *)result;
23646   return jresult;
23647 }
23648
23649
23650 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_GetDepth(void * jarg1) {
23651   unsigned int jresult ;
23652   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23653   unsigned int result;
23654
23655   arg1 = (Dali::Layer *)jarg1;
23656   {
23657     try {
23658       result = (unsigned int)((Dali::Layer const *)arg1)->GetProperty< int >( Layer::Property::DEPTH );
23659     } CALL_CATCH_EXCEPTION(0);
23660   }
23661
23662   jresult = result;
23663   return jresult;
23664 }
23665
23666
23667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Raise(void * jarg1) {
23668   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23669
23670   arg1 = (Dali::Layer *)jarg1;
23671   {
23672     try {
23673       (arg1)->Raise();
23674     } CALL_CATCH_EXCEPTION();
23675   }
23676
23677 }
23678
23679
23680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Lower(void * jarg1) {
23681   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23682
23683   arg1 = (Dali::Layer *)jarg1;
23684   {
23685     try {
23686       (arg1)->Lower();
23687     } CALL_CATCH_EXCEPTION();
23688   }
23689
23690 }
23691
23692
23693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseAbove(void * jarg1, void * jarg2) {
23694   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23695   Dali::Layer arg2 ;
23696   Dali::Layer *argp2 ;
23697
23698   arg1 = (Dali::Layer *)jarg1;
23699   argp2 = (Dali::Layer *)jarg2;
23700   if (!argp2) {
23701     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
23702     return ;
23703   }
23704   arg2 = *argp2;
23705   {
23706     try {
23707       (arg1)->RaiseAbove(arg2);
23708     } CALL_CATCH_EXCEPTION();
23709   }
23710
23711 }
23712
23713
23714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerBelow(void * jarg1, void * jarg2) {
23715   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23716   Dali::Layer arg2 ;
23717   Dali::Layer *argp2 ;
23718
23719   arg1 = (Dali::Layer *)jarg1;
23720   argp2 = (Dali::Layer *)jarg2;
23721   if (!argp2) {
23722     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
23723     return ;
23724   }
23725   arg2 = *argp2;
23726   {
23727     try {
23728       (arg1)->LowerBelow(arg2);
23729     } CALL_CATCH_EXCEPTION();
23730   }
23731
23732 }
23733
23734
23735 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseToTop(void * jarg1) {
23736   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23737
23738   arg1 = (Dali::Layer *)jarg1;
23739   {
23740     try {
23741       (arg1)->RaiseToTop();
23742     } CALL_CATCH_EXCEPTION();
23743   }
23744
23745 }
23746
23747
23748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerToBottom(void * jarg1) {
23749   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23750
23751   arg1 = (Dali::Layer *)jarg1;
23752   {
23753     try {
23754       (arg1)->LowerToBottom();
23755     } CALL_CATCH_EXCEPTION();
23756   }
23757
23758 }
23759
23760
23761 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveAbove(void * jarg1, void * jarg2) {
23762   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23763   Dali::Layer arg2 ;
23764   Dali::Layer *argp2 ;
23765
23766   arg1 = (Dali::Layer *)jarg1;
23767   argp2 = (Dali::Layer *)jarg2;
23768   if (!argp2) {
23769     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
23770     return ;
23771   }
23772   arg2 = *argp2;
23773   {
23774     try {
23775       (arg1)->MoveAbove(arg2);
23776     } CALL_CATCH_EXCEPTION();
23777   }
23778
23779 }
23780
23781
23782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveBelow(void * jarg1, void * jarg2) {
23783   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23784   Dali::Layer arg2 ;
23785   Dali::Layer *argp2 ;
23786
23787   arg1 = (Dali::Layer *)jarg1;
23788   argp2 = (Dali::Layer *)jarg2;
23789   if (!argp2) {
23790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
23791     return ;
23792   }
23793   arg2 = *argp2;
23794   {
23795     try {
23796       (arg1)->MoveBelow(arg2);
23797     } CALL_CATCH_EXCEPTION();
23798   }
23799
23800 }
23801
23802
23803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetBehavior(void * jarg1, int jarg2) {
23804   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23805   Dali::Layer::Behavior arg2 ;
23806
23807   arg1 = (Dali::Layer *)jarg1;
23808   arg2 = (Dali::Layer::Behavior)jarg2;
23809   {
23810     try {
23811       (arg1)->SetProperty( Layer::Property::BEHAVIOR, arg2 );
23812     } CALL_CATCH_EXCEPTION();
23813   }
23814
23815 }
23816
23817
23818 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_GetBehavior(void * jarg1) {
23819   int jresult ;
23820   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23821   Dali::Layer::Behavior result;
23822
23823   arg1 = (Dali::Layer *)jarg1;
23824   {
23825     try {
23826       result = (Dali::Layer::Behavior)((Dali::Layer const *)arg1)->GetProperty<Dali::Layer::Behavior>( Dali::Layer::Property::BEHAVIOR );
23827     } CALL_CATCH_EXCEPTION(0);
23828   }
23829
23830   jresult = (int)result;
23831   return jresult;
23832 }
23833
23834
23835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClipping(void * jarg1, unsigned int jarg2) {
23836   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23837   bool arg2 ;
23838
23839   arg1 = (Dali::Layer *)jarg1;
23840   arg2 = jarg2 ? true : false;
23841   {
23842     try {
23843       (arg1)->SetProperty( Dali::Layer::Property::CLIPPING_ENABLE, arg2 );
23844     } CALL_CATCH_EXCEPTION();
23845   }
23846
23847 }
23848
23849
23850 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsClipping(void * jarg1) {
23851   unsigned int jresult ;
23852   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23853   bool result;
23854
23855   arg1 = (Dali::Layer *)jarg1;
23856   {
23857     try {
23858       result = (bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Dali::Layer::Property::CLIPPING_ENABLE );
23859     } CALL_CATCH_EXCEPTION(0);
23860   }
23861
23862   jresult = result;
23863   return jresult;
23864 }
23865
23866
23867 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_0(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
23868   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23869   int arg2 ;
23870   int arg3 ;
23871   int arg4 ;
23872   int arg5 ;
23873
23874   arg1 = (Dali::Layer *)jarg1;
23875   arg2 = (int)jarg2;
23876   arg3 = (int)jarg3;
23877   arg4 = (int)jarg4;
23878   arg5 = (int)jarg5;
23879   {
23880     try {
23881       (arg1)->SetProperty( Dali::Layer::Property::CLIPPING_BOX, Rect<int32_t>( arg2,arg3,arg4,arg5 ) );
23882     } CALL_CATCH_EXCEPTION();
23883   }
23884
23885 }
23886
23887
23888 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_1(void * jarg1, void * jarg2) {
23889   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23890   Dali::ClippingBox arg2 ;
23891   Dali::ClippingBox *argp2 ;
23892
23893   arg1 = (Dali::Layer *)jarg1;
23894   argp2 = (Dali::ClippingBox *)jarg2;
23895   if (!argp2) {
23896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ClippingBox", 0);
23897     return ;
23898   }
23899   arg2 = *argp2;
23900   {
23901     try {
23902       (arg1)->SetProperty( Dali::Layer::Property::CLIPPING_BOX, arg2 );
23903     } CALL_CATCH_EXCEPTION();
23904   }
23905
23906 }
23907
23908
23909 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_GetClippingBox(void * jarg1) {
23910   void * jresult ;
23911   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23912   Dali::ClippingBox result;
23913
23914   arg1 = (Dali::Layer *)jarg1;
23915   {
23916     try {
23917       result = ((Dali::Layer const *)arg1)->GetProperty< Rect<int32_t> >( Layer::Property::CLIPPING_BOX );
23918     } CALL_CATCH_EXCEPTION(0);
23919   }
23920
23921   jresult = new Dali::ClippingBox((const Dali::ClippingBox &)result);
23922   return jresult;
23923 }
23924
23925
23926 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetDepthTestDisabled(void * jarg1, unsigned int jarg2) {
23927   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23928   bool arg2 ;
23929
23930   arg1 = (Dali::Layer *)jarg1;
23931   arg2 = jarg2 ? true : false;
23932   {
23933     try {
23934       (arg1)->SetProperty( Layer::Property::DEPTH_TEST, !arg2 );
23935     } CALL_CATCH_EXCEPTION();
23936   }
23937
23938 }
23939
23940
23941 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsDepthTestDisabled(void * jarg1) {
23942   unsigned int jresult ;
23943   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23944   bool result;
23945
23946   arg1 = (Dali::Layer *)jarg1;
23947   {
23948     try {
23949       result = !(bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Layer::Property::DEPTH_TEST );
23950     } CALL_CATCH_EXCEPTION(0);
23951   }
23952
23953   jresult = result;
23954   return jresult;
23955 }
23956
23957
23958 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetSortFunction(void * jarg1, void * jarg2) {
23959   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23960   Dali::Layer::SortFunctionType arg2 = (Dali::Layer::SortFunctionType) 0 ;
23961
23962   arg1 = (Dali::Layer *)jarg1;
23963   arg2 = (Dali::Layer::SortFunctionType)jarg2;
23964   {
23965     try {
23966       (arg1)->SetSortFunction(arg2);
23967     } CALL_CATCH_EXCEPTION();
23968   }
23969
23970 }
23971
23972
23973 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetTouchConsumed(void * jarg1, unsigned int jarg2) {
23974   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23975   bool arg2 ;
23976
23977   arg1 = (Dali::Layer *)jarg1;
23978   arg2 = jarg2 ? true : false;
23979   {
23980     try {
23981       (arg1)->SetProperty( Layer::Property::CONSUMES_TOUCH, arg2 );
23982     } CALL_CATCH_EXCEPTION();
23983   }
23984
23985 }
23986
23987
23988 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsTouchConsumed(void * jarg1) {
23989   unsigned int jresult ;
23990   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
23991   bool result;
23992
23993   arg1 = (Dali::Layer *)jarg1;
23994   {
23995     try {
23996       result = (bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Layer::Property::CONSUMES_TOUCH );
23997     } CALL_CATCH_EXCEPTION(0);
23998   }
23999
24000   jresult = result;
24001   return jresult;
24002 }
24003
24004
24005 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetHoverConsumed(void * jarg1, unsigned int jarg2) {
24006   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
24007   bool arg2 ;
24008
24009   arg1 = (Dali::Layer *)jarg1;
24010   arg2 = jarg2 ? true : false;
24011   {
24012     try {
24013       (arg1)->SetProperty( Layer::Property::CONSUMES_HOVER, arg2 );
24014     } CALL_CATCH_EXCEPTION();
24015   }
24016
24017 }
24018
24019
24020 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsHoverConsumed(void * jarg1) {
24021   unsigned int jresult ;
24022   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
24023   bool result;
24024
24025   arg1 = (Dali::Layer *)jarg1;
24026   {
24027     try {
24028       result = (bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Layer::Property::CONSUMES_HOVER );
24029     } CALL_CATCH_EXCEPTION(0);
24030   }
24031
24032   jresult = result;
24033   return jresult;
24034 }
24035
24036
24037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetCurrent() {
24038   void * jresult ;
24039   Dali::Stage result;
24040
24041   {
24042     try {
24043       result = Dali::Stage::GetCurrent();
24044     } CALL_CATCH_EXCEPTION(0);
24045   }
24046
24047   jresult = new Dali::Stage((const Dali::Stage &)result);
24048   return jresult;
24049 }
24050
24051
24052 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_IsInstalled() {
24053   unsigned int jresult ;
24054   bool result;
24055
24056   {
24057     try {
24058       result = (bool)Dali::Stage::IsInstalled();
24059     } CALL_CATCH_EXCEPTION(0);
24060   }
24061
24062   jresult = result;
24063   return jresult;
24064 }
24065
24066
24067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetDpi(void * jarg1) {
24068   void * jresult ;
24069   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
24070   Dali::Vector2 result;
24071
24072   arg1 = (Dali::Stage *)jarg1;
24073   {
24074     try {
24075       result = ((Dali::Stage const *)arg1)->GetDpi();
24076     } CALL_CATCH_EXCEPTION(0);
24077   }
24078
24079   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
24080   return jresult;
24081 }
24082
24083
24084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_KeepRendering(void * jarg1, float jarg2) {
24085   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
24086   float arg2 ;
24087
24088   arg1 = (Dali::Stage *)jarg1;
24089   arg2 = (float)jarg2;
24090   {
24091     try {
24092       (arg1)->KeepRendering(arg2);
24093     } CALL_CATCH_EXCEPTION();
24094   }
24095
24096 }
24097
24098
24099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_KeyEventSignal(void * jarg1) {
24100   void * jresult ;
24101   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
24102   Dali::Stage::KeyEventSignalType *result = 0 ;
24103
24104   arg1 = (Dali::Stage *)jarg1;
24105   {
24106     try {
24107       result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal();
24108     } CALL_CATCH_EXCEPTION(0);
24109   }
24110
24111   jresult = (void *)result;
24112   return jresult;
24113 }
24114
24115
24116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_EventProcessingFinishedSignal(void * jarg1) {
24117   void * jresult ;
24118   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
24119   Dali::Stage::EventProcessingFinishedSignalType *result = 0 ;
24120
24121   arg1 = (Dali::Stage *)jarg1;
24122   {
24123     try {
24124       result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal();
24125     } CALL_CATCH_EXCEPTION(0);
24126   }
24127
24128   jresult = (void *)result;
24129   return jresult;
24130 }
24131
24132
24133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_TouchSignal(void * jarg1) {
24134   void * jresult ;
24135   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
24136   Dali::Stage::TouchSignalType *result = 0 ;
24137
24138   arg1 = (Dali::Stage *)jarg1;
24139   {
24140     try {
24141       result = (Dali::Stage::TouchSignalType *) &(arg1)->TouchSignal();
24142     } CALL_CATCH_EXCEPTION(0);
24143   }
24144
24145   jresult = (void *)result;
24146   return jresult;
24147 }
24148
24149
24150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_WheelEventSignal(void * jarg1) {
24151   void * jresult ;
24152   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
24153   Dali::Stage::WheelEventSignalType *result = 0 ;
24154
24155   arg1 = (Dali::Stage *)jarg1;
24156   {
24157     try {
24158       result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal();
24159     } CALL_CATCH_EXCEPTION(0);
24160   }
24161
24162   jresult = (void *)result;
24163   return jresult;
24164 }
24165
24166
24167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextLostSignal(void * jarg1) {
24168   void * jresult ;
24169   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
24170   Dali::Stage::ContextStatusSignal *result = 0 ;
24171
24172   arg1 = (Dali::Stage *)jarg1;
24173   {
24174     try {
24175       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal();
24176     } CALL_CATCH_EXCEPTION(0);
24177   }
24178
24179   jresult = (void *)result;
24180   return jresult;
24181 }
24182
24183
24184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextRegainedSignal(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)->ContextRegainedSignal();
24193     } CALL_CATCH_EXCEPTION(0);
24194   }
24195
24196   jresult = (void *)result;
24197   return jresult;
24198 }
24199
24200
24201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_SceneCreatedSignal(void * jarg1) {
24202   void * jresult ;
24203   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
24204   Dali::Stage::SceneCreatedSignalType *result = 0 ;
24205
24206   arg1 = (Dali::Stage *)jarg1;
24207   {
24208     try {
24209       result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal();
24210     } CALL_CATCH_EXCEPTION(0);
24211   }
24212
24213   jresult = (void *)result;
24214   return jresult;
24215 }
24216
24217 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetRenderingBehavior(void * jarg1, int jarg2) {
24218   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
24219   Dali::DevelStage::Rendering arg2 ;
24220
24221   arg1 = (Dali::Stage *)jarg1;
24222   arg2 = (Dali::DevelStage::Rendering)jarg2;
24223   {
24224     try {
24225       DevelStage::SetRenderingBehavior(*arg1,arg2);
24226     } CALL_CATCH_EXCEPTION();
24227   }
24228
24229 }
24230
24231 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Stage_GetRenderingBehavior(void * jarg1) {
24232
24233   int jresult ;
24234   int result ;
24235   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
24236
24237   arg1 = (Dali::Stage *)jarg1;
24238   {
24239     try {
24240       result = (int)(DevelStage::GetRenderingBehavior(*arg1));
24241     } CALL_CATCH_EXCEPTION(0);
24242   }
24243
24244   jresult = result;
24245   return jresult;
24246 }
24247
24248 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RelayoutContainer(void * jarg1) {
24249   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
24250
24251   arg1 = (Dali::RelayoutContainer *)jarg1;
24252   {
24253     try {
24254       delete arg1;
24255     } CALL_CATCH_EXCEPTION();
24256   }
24257
24258 }
24259
24260
24261 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) {
24262   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
24263   Dali::Actor *arg2 = 0 ;
24264   Dali::Vector2 *arg3 = 0 ;
24265
24266   arg1 = (Dali::RelayoutContainer *)jarg1;
24267   arg2 = (Dali::Actor *)jarg2;
24268   if (!arg2) {
24269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
24270     return ;
24271   }
24272   arg3 = (Dali::Vector2 *)jarg3;
24273   if (!arg3) {
24274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
24275     return ;
24276   }
24277   {
24278     try {
24279       (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3);
24280     } CALL_CATCH_EXCEPTION();
24281   }
24282
24283 }
24284
24285
24286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_Self(void * jarg1) {
24287   void * jresult ;
24288   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24289   Dali::CustomActor result;
24290
24291   arg1 = (Dali::CustomActorImpl *)jarg1;
24292   {
24293     try {
24294       result = ((Dali::CustomActorImpl const *)arg1)->Self();
24295     } CALL_CATCH_EXCEPTION(0);
24296   }
24297
24298   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
24299   return jresult;
24300 }
24301
24302
24303 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSceneConnection(void * jarg1, int jarg2) {
24304   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24305   int arg2 ;
24306
24307   arg1 = (Dali::CustomActorImpl *)jarg1;
24308   arg2 = (int)jarg2;
24309   {
24310     try {
24311       (arg1)->OnSceneConnection(arg2);
24312     } CALL_CATCH_EXCEPTION();
24313   }
24314
24315 }
24316
24317
24318 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSceneDisconnection(void * jarg1) {
24319   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24320
24321   arg1 = (Dali::CustomActorImpl *)jarg1;
24322   {
24323     try {
24324       (arg1)->OnSceneDisconnection();
24325     } CALL_CATCH_EXCEPTION();
24326   }
24327
24328 }
24329
24330
24331 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildAdd(void * jarg1, void * jarg2) {
24332   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24333   Dali::Actor *arg2 = 0 ;
24334
24335   arg1 = (Dali::CustomActorImpl *)jarg1;
24336   arg2 = (Dali::Actor *)jarg2;
24337   if (!arg2) {
24338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
24339     return ;
24340   }
24341   {
24342     try {
24343       (arg1)->OnChildAdd(*arg2);
24344     } CALL_CATCH_EXCEPTION();
24345   }
24346
24347 }
24348
24349
24350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) {
24351   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24352   Dali::Actor *arg2 = 0 ;
24353
24354   arg1 = (Dali::CustomActorImpl *)jarg1;
24355   arg2 = (Dali::Actor *)jarg2;
24356   if (!arg2) {
24357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
24358     return ;
24359   }
24360   {
24361     try {
24362       (arg1)->OnChildRemove(*arg2);
24363     } CALL_CATCH_EXCEPTION();
24364   }
24365
24366 }
24367
24368
24369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
24370   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24371   Dali::Property::Index arg2 ;
24372   Dali::Property::Value arg3 ;
24373   Dali::Property::Value *argp3 ;
24374
24375   arg1 = (Dali::CustomActorImpl *)jarg1;
24376   arg2 = (Dali::Property::Index)jarg2;
24377   argp3 = (Dali::Property::Value *)jarg3;
24378   if (!argp3) {
24379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
24380     return ;
24381   }
24382   arg3 = *argp3;
24383   {
24384     try {
24385       (arg1)->OnPropertySet(arg2,arg3);
24386     } CALL_CATCH_EXCEPTION();
24387   }
24388
24389 }
24390
24391
24392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeSet(void * jarg1, void * jarg2) {
24393   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24394   Dali::Vector3 *arg2 = 0 ;
24395
24396   arg1 = (Dali::CustomActorImpl *)jarg1;
24397   arg2 = (Dali::Vector3 *)jarg2;
24398   if (!arg2) {
24399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
24400     return ;
24401   }
24402   {
24403     try {
24404       (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2);
24405     } CALL_CATCH_EXCEPTION();
24406   }
24407
24408 }
24409
24410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
24411   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24412   Dali::Animation *arg2 = 0 ;
24413   Dali::Vector3 *arg3 = 0 ;
24414
24415   arg1 = (Dali::CustomActorImpl *)jarg1;
24416   arg2 = (Dali::Animation *)jarg2;
24417   if (!arg2) {
24418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
24419     return ;
24420   }
24421   arg3 = (Dali::Vector3 *)jarg3;
24422   if (!arg3) {
24423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
24424     return ;
24425   }
24426   {
24427     try {
24428       (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
24429     } CALL_CATCH_EXCEPTION();
24430   }
24431 }
24432
24433 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnHoverEvent(void * jarg1, void * jarg2) {
24434   unsigned int jresult ;
24435   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24436   Dali::HoverEvent *arg2 = 0 ;
24437   bool result;
24438
24439   arg1 = (Dali::CustomActorImpl *)jarg1;
24440   arg2 = (Dali::HoverEvent *)jarg2;
24441   if (!arg2) {
24442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
24443     return 0;
24444   }
24445   {
24446     try {
24447       result = (bool)(arg1)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
24448     } CALL_CATCH_EXCEPTION(0);
24449   }
24450
24451   jresult = result;
24452   return jresult;
24453 }
24454
24455
24456 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnKeyEvent(void * jarg1, void * jarg2) {
24457   unsigned int jresult ;
24458   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24459   Dali::KeyEvent *arg2 = 0 ;
24460   bool result;
24461
24462   arg1 = (Dali::CustomActorImpl *)jarg1;
24463   arg2 = (Dali::KeyEvent *)jarg2;
24464   if (!arg2) {
24465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
24466     return 0;
24467   }
24468   {
24469     try {
24470       result = (bool)(arg1)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
24471     } CALL_CATCH_EXCEPTION(0);
24472   }
24473
24474   jresult = result;
24475   return jresult;
24476 }
24477
24478
24479 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnWheelEvent(void * jarg1, void * jarg2) {
24480   unsigned int jresult ;
24481   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24482   Dali::WheelEvent *arg2 = 0 ;
24483   bool result;
24484
24485   arg1 = (Dali::CustomActorImpl *)jarg1;
24486   arg2 = (Dali::WheelEvent *)jarg2;
24487   if (!arg2) {
24488     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
24489     return 0;
24490   }
24491   {
24492     try {
24493       result = (bool)(arg1)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
24494     } CALL_CATCH_EXCEPTION(0);
24495   }
24496
24497   jresult = result;
24498   return jresult;
24499 }
24500
24501
24502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
24503   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24504   Dali::Vector2 *arg2 = 0 ;
24505   Dali::RelayoutContainer *arg3 = 0 ;
24506
24507   arg1 = (Dali::CustomActorImpl *)jarg1;
24508   arg2 = (Dali::Vector2 *)jarg2;
24509   if (!arg2) {
24510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
24511     return ;
24512   }
24513   arg3 = (Dali::RelayoutContainer *)jarg3;
24514   if (!arg3) {
24515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
24516     return ;
24517   }
24518   {
24519     try {
24520       (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
24521     } CALL_CATCH_EXCEPTION();
24522   }
24523
24524 }
24525
24526
24527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
24528   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24529   Dali::ResizePolicy::Type arg2 ;
24530   Dali::Dimension::Type arg3 ;
24531
24532   arg1 = (Dali::CustomActorImpl *)jarg1;
24533   arg2 = (Dali::ResizePolicy::Type)jarg2;
24534   arg3 = (Dali::Dimension::Type)jarg3;
24535   {
24536     try {
24537       (arg1)->OnSetResizePolicy(arg2,arg3);
24538     } CALL_CATCH_EXCEPTION();
24539   }
24540
24541 }
24542
24543
24544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetNaturalSize(void * jarg1) {
24545   void * jresult ;
24546   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24547   Dali::Vector3 result;
24548
24549   arg1 = (Dali::CustomActorImpl *)jarg1;
24550   {
24551     try {
24552       result = (arg1)->GetNaturalSize();
24553     } CALL_CATCH_EXCEPTION(0);
24554   }
24555
24556   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
24557   return jresult;
24558 }
24559
24560
24561 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
24562   float jresult ;
24563   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24564   Dali::Actor *arg2 = 0 ;
24565   Dali::Dimension::Type arg3 ;
24566   float result;
24567
24568   arg1 = (Dali::CustomActorImpl *)jarg1;
24569   arg2 = (Dali::Actor *)jarg2;
24570   if (!arg2) {
24571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
24572     return 0;
24573   }
24574   arg3 = (Dali::Dimension::Type)jarg3;
24575   {
24576     try {
24577       result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
24578     } CALL_CATCH_EXCEPTION(0);
24579   }
24580
24581   jresult = result;
24582   return jresult;
24583 }
24584
24585
24586 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) {
24587   float jresult ;
24588   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24589   float arg2 ;
24590   float result;
24591
24592   arg1 = (Dali::CustomActorImpl *)jarg1;
24593   arg2 = (float)jarg2;
24594   {
24595     try {
24596       result = (float)(arg1)->GetHeightForWidth(arg2);
24597     } CALL_CATCH_EXCEPTION(0);
24598   }
24599
24600   jresult = result;
24601   return jresult;
24602 }
24603
24604
24605 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) {
24606   float jresult ;
24607   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24608   float arg2 ;
24609   float result;
24610
24611   arg1 = (Dali::CustomActorImpl *)jarg1;
24612   arg2 = (float)jarg2;
24613   {
24614     try {
24615       result = (float)(arg1)->GetWidthForHeight(arg2);
24616     } CALL_CATCH_EXCEPTION(0);
24617   }
24618
24619   jresult = result;
24620   return jresult;
24621 }
24622
24623
24624 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
24625   unsigned int jresult ;
24626   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24627   Dali::Dimension::Type arg2 ;
24628   bool result;
24629
24630   arg1 = (Dali::CustomActorImpl *)jarg1;
24631   arg2 = (Dali::Dimension::Type)jarg2;
24632   {
24633     try {
24634       result = (bool)(arg1)->RelayoutDependentOnChildren(arg2);
24635     } CALL_CATCH_EXCEPTION(0);
24636   }
24637
24638   jresult = result;
24639   return jresult;
24640 }
24641
24642
24643 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
24644   unsigned int jresult ;
24645   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24646   bool result;
24647
24648   arg1 = (Dali::CustomActorImpl *)jarg1;
24649   {
24650     try {
24651       result = (bool)(arg1)->RelayoutDependentOnChildren();
24652     } CALL_CATCH_EXCEPTION(0);
24653   }
24654
24655   jresult = result;
24656   return jresult;
24657 }
24658
24659
24660 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
24661   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24662   Dali::Dimension::Type arg2 ;
24663
24664   arg1 = (Dali::CustomActorImpl *)jarg1;
24665   arg2 = (Dali::Dimension::Type)jarg2;
24666   {
24667     try {
24668       (arg1)->OnCalculateRelayoutSize(arg2);
24669     } CALL_CATCH_EXCEPTION();
24670   }
24671
24672 }
24673
24674
24675 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
24676   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24677   float arg2 ;
24678   Dali::Dimension::Type arg3 ;
24679
24680   arg1 = (Dali::CustomActorImpl *)jarg1;
24681   arg2 = (float)jarg2;
24682   arg3 = (Dali::Dimension::Type)jarg3;
24683   {
24684     try {
24685       (arg1)->OnLayoutNegotiated(arg2,arg3);
24686     } CALL_CATCH_EXCEPTION();
24687   }
24688
24689 }
24690
24691
24692 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresTouchEvents(void * jarg1) {
24693   unsigned int jresult ;
24694   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
24695   bool result;
24696
24697   arg1 = (Dali::CustomActorImpl *)jarg1;
24698   {
24699     try {
24700       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresTouchEvents();
24701     } CALL_CATCH_EXCEPTION(0);
24702   }
24703
24704   jresult = result;
24705   return jresult;
24706 }
24707
24708
24709 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresHoverEvents(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)->RequiresHoverEvents();
24718     } CALL_CATCH_EXCEPTION(0);
24719   }
24720
24721   jresult = result;
24722   return jresult;
24723 }
24724
24725
24726 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresWheelEvents(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)->RequiresWheelEvents();
24735     } CALL_CATCH_EXCEPTION(0);
24736   }
24737
24738   jresult = result;
24739   return jresult;
24740 }
24741
24742
24743 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_IsRelayoutEnabled(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)->IsRelayoutEnabled();
24752     } CALL_CATCH_EXCEPTION(0);
24753   }
24754
24755   jresult = result;
24756   return jresult;
24757 }
24758
24759
24760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_0() {
24761   void * jresult ;
24762   Dali::CustomActor *result = 0 ;
24763
24764   {
24765     try {
24766       result = (Dali::CustomActor *)new Dali::CustomActor();
24767     } CALL_CATCH_EXCEPTION(0);
24768   }
24769
24770   jresult = (void *)result;
24771   return jresult;
24772 }
24773
24774
24775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_DownCast(void * jarg1) {
24776   void * jresult ;
24777   Dali::BaseHandle arg1 ;
24778   Dali::BaseHandle *argp1 ;
24779   Dali::CustomActor result;
24780
24781   argp1 = (Dali::BaseHandle *)jarg1;
24782   if (!argp1) {
24783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24784     return 0;
24785   }
24786   arg1 = *argp1;
24787   {
24788     try {
24789       result = Dali::CustomActor::DownCast(arg1);
24790     } CALL_CATCH_EXCEPTION(0);
24791   }
24792
24793   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
24794   return jresult;
24795 }
24796
24797
24798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomActor(void * jarg1) {
24799   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
24800
24801   arg1 = (Dali::CustomActor *)jarg1;
24802   {
24803     try {
24804       delete arg1;
24805     } CALL_CATCH_EXCEPTION();
24806   }
24807
24808 }
24809
24810
24811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_GetImplementation(void * jarg1) {
24812   void * jresult ;
24813   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
24814   Dali::CustomActorImpl *result = 0 ;
24815
24816   arg1 = (Dali::CustomActor *)jarg1;
24817   {
24818     try {
24819       result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation();
24820     } CALL_CATCH_EXCEPTION(0);
24821   }
24822
24823   jresult = (void *)result;
24824   return jresult;
24825 }
24826
24827
24828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_1(void * jarg1) {
24829   void * jresult ;
24830   Dali::CustomActorImpl *arg1 = 0 ;
24831   Dali::CustomActor *result = 0 ;
24832
24833   arg1 = (Dali::CustomActorImpl *)jarg1;
24834   if (!arg1) {
24835     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0);
24836     return 0;
24837   }
24838   {
24839     try {
24840       result = (Dali::CustomActor *)new Dali::CustomActor(*arg1);
24841     } CALL_CATCH_EXCEPTION(0);
24842   }
24843
24844   jresult = (void *)result;
24845   return jresult;
24846 }
24847
24848
24849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_2(void * jarg1) {
24850   void * jresult ;
24851   Dali::CustomActor *arg1 = 0 ;
24852   Dali::CustomActor *result = 0 ;
24853
24854   arg1 = (Dali::CustomActor *)jarg1;
24855   if (!arg1) {
24856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
24857     return 0;
24858   }
24859   {
24860     try {
24861       result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*arg1);
24862     } CALL_CATCH_EXCEPTION(0);
24863   }
24864
24865   jresult = (void *)result;
24866   return jresult;
24867 }
24868
24869
24870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_Assign(void * jarg1, void * jarg2) {
24871   void * jresult ;
24872   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
24873   Dali::CustomActor *arg2 = 0 ;
24874   Dali::CustomActor *result = 0 ;
24875
24876   arg1 = (Dali::CustomActor *)jarg1;
24877   arg2 = (Dali::CustomActor *)jarg2;
24878   if (!arg2) {
24879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
24880     return 0;
24881   }
24882   {
24883     try {
24884       result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2);
24885     } CALL_CATCH_EXCEPTION(0);
24886   }
24887
24888   jresult = (void *)result;
24889   return jresult;
24890 }
24891
24892
24893 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_POSITION_get() {
24894   int jresult ;
24895   int result;
24896
24897   result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION;
24898   jresult = (int)result;
24899   return jresult;
24900 }
24901
24902
24903 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() {
24904   int jresult ;
24905   int result;
24906
24907   result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT;
24908   jresult = (int)result;
24909   return jresult;
24910 }
24911
24912
24913 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_VELOCITY_get() {
24914   int jresult ;
24915   int result;
24916
24917   result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY;
24918   jresult = (int)result;
24919   return jresult;
24920 }
24921
24922
24923 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_POSITION_get() {
24924   int jresult ;
24925   int result;
24926
24927   result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION;
24928   jresult = (int)result;
24929   return jresult;
24930 }
24931
24932
24933 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() {
24934   int jresult ;
24935   int result;
24936
24937   result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT;
24938   jresult = (int)result;
24939   return jresult;
24940 }
24941
24942
24943 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_VELOCITY_get() {
24944   int jresult ;
24945   int result;
24946
24947   result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY;
24948   jresult = (int)result;
24949   return jresult;
24950 }
24951
24952
24953 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_PANNING_get() {
24954   int jresult ;
24955   int result;
24956
24957   result = (int)Dali::PanGestureDetector::Property::PANNING;
24958   jresult = (int)result;
24959   return jresult;
24960 }
24961
24962
24963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector_Property() {
24964   void * jresult ;
24965   Dali::PanGestureDetector::Property *result = 0 ;
24966
24967   {
24968     try {
24969       result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property();
24970     } CALL_CATCH_EXCEPTION(0);
24971   }
24972
24973   jresult = (void *)result;
24974   return jresult;
24975 }
24976
24977
24978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector_Property(void * jarg1) {
24979   Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ;
24980
24981   arg1 = (Dali::PanGestureDetector::Property *)jarg1;
24982   {
24983     try {
24984       delete arg1;
24985     } CALL_CATCH_EXCEPTION();
24986   }
24987
24988 }
24989
24990
24991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_LEFT_get() {
24992   void * jresult ;
24993   Dali::Radian *result = 0 ;
24994
24995   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT;
24996   jresult = (void *)result;
24997   return jresult;
24998 }
24999
25000
25001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_RIGHT_get() {
25002   void * jresult ;
25003   Dali::Radian *result = 0 ;
25004
25005   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT;
25006   jresult = (void *)result;
25007   return jresult;
25008 }
25009
25010
25011 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_UP_get() {
25012   void * jresult ;
25013   Dali::Radian *result = 0 ;
25014
25015   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP;
25016   jresult = (void *)result;
25017   return jresult;
25018 }
25019
25020
25021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_DOWN_get() {
25022   void * jresult ;
25023   Dali::Radian *result = 0 ;
25024
25025   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN;
25026   jresult = (void *)result;
25027   return jresult;
25028 }
25029
25030
25031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_HORIZONTAL_get() {
25032   void * jresult ;
25033   Dali::Radian *result = 0 ;
25034
25035   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL;
25036   jresult = (void *)result;
25037   return jresult;
25038 }
25039
25040
25041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_VERTICAL_get() {
25042   void * jresult ;
25043   Dali::Radian *result = 0 ;
25044
25045   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL;
25046   jresult = (void *)result;
25047   return jresult;
25048 }
25049
25050
25051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DEFAULT_THRESHOLD_get() {
25052   void * jresult ;
25053   Dali::Radian *result = 0 ;
25054
25055   result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD;
25056   jresult = (void *)result;
25057   return jresult;
25058 }
25059
25060
25061 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_0() {
25062   void * jresult ;
25063   Dali::PanGestureDetector *result = 0 ;
25064
25065   {
25066     try {
25067       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector();
25068     } CALL_CATCH_EXCEPTION(0);
25069   }
25070
25071   jresult = (void *)result;
25072   return jresult;
25073 }
25074
25075
25076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_New() {
25077   void * jresult ;
25078   Dali::PanGestureDetector result;
25079
25080   {
25081     try {
25082       result = Dali::PanGestureDetector::New();
25083     } CALL_CATCH_EXCEPTION(0);
25084   }
25085
25086   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
25087   return jresult;
25088 }
25089
25090
25091 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DownCast(void * jarg1) {
25092   void * jresult ;
25093   Dali::BaseHandle arg1 ;
25094   Dali::BaseHandle *argp1 ;
25095   Dali::PanGestureDetector result;
25096
25097   argp1 = (Dali::BaseHandle *)jarg1;
25098   if (!argp1) {
25099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25100     return 0;
25101   }
25102   arg1 = *argp1;
25103   {
25104     try {
25105       result = Dali::PanGestureDetector::DownCast(arg1);
25106     } CALL_CATCH_EXCEPTION(0);
25107   }
25108
25109   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
25110   return jresult;
25111 }
25112
25113
25114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector(void * jarg1) {
25115   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25116
25117   arg1 = (Dali::PanGestureDetector *)jarg1;
25118   {
25119     try {
25120       delete arg1;
25121     } CALL_CATCH_EXCEPTION();
25122   }
25123
25124 }
25125
25126
25127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_1(void * jarg1) {
25128   void * jresult ;
25129   Dali::PanGestureDetector *arg1 = 0 ;
25130   Dali::PanGestureDetector *result = 0 ;
25131
25132   arg1 = (Dali::PanGestureDetector *)jarg1;
25133   if (!arg1) {
25134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
25135     return 0;
25136   }
25137   {
25138     try {
25139       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1);
25140     } CALL_CATCH_EXCEPTION(0);
25141   }
25142
25143   jresult = (void *)result;
25144   return jresult;
25145 }
25146
25147
25148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_Assign(void * jarg1, void * jarg2) {
25149   void * jresult ;
25150   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25151   Dali::PanGestureDetector *arg2 = 0 ;
25152   Dali::PanGestureDetector *result = 0 ;
25153
25154   arg1 = (Dali::PanGestureDetector *)jarg1;
25155   arg2 = (Dali::PanGestureDetector *)jarg2;
25156   if (!arg2) {
25157     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
25158     return 0;
25159   }
25160   {
25161     try {
25162       result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2);
25163     } CALL_CATCH_EXCEPTION(0);
25164   }
25165
25166   jresult = (void *)result;
25167   return jresult;
25168 }
25169
25170
25171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) {
25172   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25173   unsigned int arg2 ;
25174
25175   arg1 = (Dali::PanGestureDetector *)jarg1;
25176   arg2 = (unsigned int)jarg2;
25177   {
25178     try {
25179       (arg1)->SetMinimumTouchesRequired(arg2);
25180     } CALL_CATCH_EXCEPTION();
25181   }
25182
25183 }
25184
25185
25186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) {
25187   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25188   unsigned int arg2 ;
25189
25190   arg1 = (Dali::PanGestureDetector *)jarg1;
25191   arg2 = (unsigned int)jarg2;
25192   {
25193     try {
25194       (arg1)->SetMaximumTouchesRequired(arg2);
25195     } CALL_CATCH_EXCEPTION();
25196   }
25197
25198 }
25199
25200
25201 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
25202   unsigned int jresult ;
25203   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25204   unsigned int result;
25205
25206   arg1 = (Dali::PanGestureDetector *)jarg1;
25207   {
25208     try {
25209       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired();
25210     } CALL_CATCH_EXCEPTION(0);
25211   }
25212
25213   jresult = result;
25214   return jresult;
25215 }
25216
25217
25218 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumTouchesRequired(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)->GetMaximumTouchesRequired();
25227     } CALL_CATCH_EXCEPTION(0);
25228   }
25229
25230   jresult = result;
25231   return jresult;
25232 }
25233
25234
25235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
25236   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25237   Dali::Radian arg2 ;
25238   Dali::Radian arg3 ;
25239   Dali::Radian *argp2 ;
25240   Dali::Radian *argp3 ;
25241
25242   arg1 = (Dali::PanGestureDetector *)jarg1;
25243   argp2 = (Dali::Radian *)jarg2;
25244   if (!argp2) {
25245     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
25246     return ;
25247   }
25248   arg2 = *argp2;
25249   argp3 = (Dali::Radian *)jarg3;
25250   if (!argp3) {
25251     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
25252     return ;
25253   }
25254   arg3 = *argp3;
25255   {
25256     try {
25257       (arg1)->AddAngle(arg2,arg3);
25258     } CALL_CATCH_EXCEPTION();
25259   }
25260
25261 }
25262
25263
25264 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) {
25265   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25266   Dali::Radian arg2 ;
25267   Dali::Radian *argp2 ;
25268
25269   arg1 = (Dali::PanGestureDetector *)jarg1;
25270   argp2 = (Dali::Radian *)jarg2;
25271   if (!argp2) {
25272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
25273     return ;
25274   }
25275   arg2 = *argp2;
25276   {
25277     try {
25278       (arg1)->AddAngle(arg2);
25279     } CALL_CATCH_EXCEPTION();
25280   }
25281
25282 }
25283
25284
25285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
25286   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25287   Dali::Radian arg2 ;
25288   Dali::Radian arg3 ;
25289   Dali::Radian *argp2 ;
25290   Dali::Radian *argp3 ;
25291
25292   arg1 = (Dali::PanGestureDetector *)jarg1;
25293   argp2 = (Dali::Radian *)jarg2;
25294   if (!argp2) {
25295     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
25296     return ;
25297   }
25298   arg2 = *argp2;
25299   argp3 = (Dali::Radian *)jarg3;
25300   if (!argp3) {
25301     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
25302     return ;
25303   }
25304   arg3 = *argp3;
25305   {
25306     try {
25307       (arg1)->AddDirection(arg2,arg3);
25308     } CALL_CATCH_EXCEPTION();
25309   }
25310
25311 }
25312
25313
25314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) {
25315   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25316   Dali::Radian arg2 ;
25317   Dali::Radian *argp2 ;
25318
25319   arg1 = (Dali::PanGestureDetector *)jarg1;
25320   argp2 = (Dali::Radian *)jarg2;
25321   if (!argp2) {
25322     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
25323     return ;
25324   }
25325   arg2 = *argp2;
25326   {
25327     try {
25328       (arg1)->AddDirection(arg2);
25329     } CALL_CATCH_EXCEPTION();
25330   }
25331
25332 }
25333
25334
25335 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngleCount(void * jarg1) {
25336   unsigned long jresult ;
25337   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25338   size_t result;
25339
25340   arg1 = (Dali::PanGestureDetector *)jarg1;
25341   {
25342     try {
25343       result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount();
25344     } CALL_CATCH_EXCEPTION(0);
25345   }
25346
25347   jresult = (unsigned long)result;
25348   return jresult;
25349 }
25350
25351
25352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) {
25353   void * jresult ;
25354   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25355   size_t arg2 ;
25356   Dali::PanGestureDetector::AngleThresholdPair result;
25357
25358   arg1 = (Dali::PanGestureDetector *)jarg1;
25359   arg2 = (size_t)jarg2;
25360   {
25361     try {
25362       result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2);
25363     } CALL_CATCH_EXCEPTION(0);
25364   }
25365
25366   jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result);
25367   return jresult;
25368 }
25369
25370
25371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_ClearAngles(void * jarg1) {
25372   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25373
25374   arg1 = (Dali::PanGestureDetector *)jarg1;
25375   {
25376     try {
25377       (arg1)->ClearAngles();
25378     } CALL_CATCH_EXCEPTION();
25379   }
25380
25381 }
25382
25383
25384 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) {
25385   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25386   Dali::Radian arg2 ;
25387   Dali::Radian *argp2 ;
25388
25389   arg1 = (Dali::PanGestureDetector *)jarg1;
25390   argp2 = (Dali::Radian *)jarg2;
25391   if (!argp2) {
25392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
25393     return ;
25394   }
25395   arg2 = *argp2;
25396   {
25397     try {
25398       (arg1)->RemoveAngle(arg2);
25399     } CALL_CATCH_EXCEPTION();
25400   }
25401
25402 }
25403
25404
25405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveDirection(void * jarg1, void * jarg2) {
25406   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25407   Dali::Radian arg2 ;
25408   Dali::Radian *argp2 ;
25409
25410   arg1 = (Dali::PanGestureDetector *)jarg1;
25411   argp2 = (Dali::Radian *)jarg2;
25412   if (!argp2) {
25413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
25414     return ;
25415   }
25416   arg2 = *argp2;
25417   {
25418     try {
25419       (arg1)->RemoveDirection(arg2);
25420     } CALL_CATCH_EXCEPTION();
25421   }
25422
25423 }
25424
25425
25426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DetectedSignal(void * jarg1) {
25427   void * jresult ;
25428   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
25429   Dali::PanGestureDetector::DetectedSignalType *result = 0 ;
25430
25431   arg1 = (Dali::PanGestureDetector *)jarg1;
25432   {
25433     try {
25434       result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
25435     } CALL_CATCH_EXCEPTION(0);
25436   }
25437
25438   jresult = (void *)result;
25439   return jresult;
25440 }
25441
25442
25443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetPanGestureProperties(void * jarg1) {
25444   Dali::PanGesture *arg1 = 0 ;
25445
25446   arg1 = (Dali::PanGesture *)jarg1;
25447   if (!arg1) {
25448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
25449     return ;
25450   }
25451   {
25452     try {
25453       Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1);
25454     } CALL_CATCH_EXCEPTION();
25455   }
25456
25457 }
25458
25459
25460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_0() {
25461   void * jresult ;
25462   Dali::PanGesture *result = 0 ;
25463
25464   {
25465     try {
25466       result = (Dali::PanGesture *)new Dali::PanGesture();
25467     } CALL_CATCH_EXCEPTION(0);
25468   }
25469
25470   jresult = (void *)result;
25471   return jresult;
25472 }
25473
25474 // Need to delete this
25475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_1(int jarg1) {
25476   void * jresult ;
25477   Dali::Gesture::State arg1 ;
25478   Dali::PanGesture *result = 0 ;
25479
25480   arg1 = (Dali::Gesture::State)jarg1;
25481   {
25482     try {
25483       result = (Dali::PanGesture *)new Dali::PanGesture();
25484     } catch (std::out_of_range& e) {
25485       {
25486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25487       };
25488     } catch (std::exception& e) {
25489       {
25490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25491       };
25492     } catch (Dali::DaliException e) {
25493       {
25494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25495       };
25496     } catch (...) {
25497       {
25498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25499       };
25500     }
25501   }
25502
25503   jresult = (void *)result;
25504   return jresult;
25505 }
25506
25507
25508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_2(void * jarg1) {
25509   void * jresult ;
25510   Dali::PanGesture *arg1 = 0 ;
25511   Dali::PanGesture *result = 0 ;
25512
25513   arg1 = (Dali::PanGesture *)jarg1;
25514   if (!arg1) {
25515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
25516     return 0;
25517   }
25518   {
25519     try {
25520       result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*arg1);
25521     } CALL_CATCH_EXCEPTION(0);
25522   }
25523
25524   jresult = (void *)result;
25525   return jresult;
25526 }
25527
25528
25529 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_Assign(void * jarg1, void * jarg2) {
25530   void * jresult ;
25531   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
25532   Dali::PanGesture *arg2 = 0 ;
25533   Dali::PanGesture *result = 0 ;
25534
25535   arg1 = (Dali::PanGesture *)jarg1;
25536   arg2 = (Dali::PanGesture *)jarg2;
25537   if (!arg2) {
25538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
25539     return 0;
25540   }
25541   {
25542     try {
25543       result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2);
25544     } CALL_CATCH_EXCEPTION(0);
25545   }
25546
25547   jresult = (void *)result;
25548   return jresult;
25549 }
25550
25551
25552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGesture(void * jarg1) {
25553   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
25554
25555   arg1 = (Dali::PanGesture *)jarg1;
25556   {
25557     try {
25558       delete arg1;
25559     } CALL_CATCH_EXCEPTION();
25560   }
25561
25562 }
25563
25564
25565 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_velocity_get(void * jarg1) {
25566   void * jresult ;
25567   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
25568   Dali::Vector2 result;
25569
25570   arg1 = (Dali::PanGesture *)jarg1;
25571   {
25572     try {
25573       result = ((Dali::PanGesture const *)arg1)->GetVelocity();
25574     } catch (std::out_of_range& e) {
25575       {
25576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25577       };
25578     } catch (std::exception& e) {
25579       {
25580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25581       };
25582     } catch (Dali::DaliException e) {
25583       {
25584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25585       };
25586     } catch (...) {
25587       {
25588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25589       };
25590     }
25591   }
25592   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
25593   return jresult;
25594 }
25595
25596
25597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_displacement_get(void * jarg1) {
25598   void * jresult ;
25599   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
25600   Dali::Vector2 result;
25601
25602   arg1 = (Dali::PanGesture *)jarg1;
25603   {
25604     try {
25605       result = ((Dali::PanGesture const *)arg1)->GetDisplacement();
25606     } catch (std::out_of_range& e) {
25607       {
25608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25609       };
25610     } catch (std::exception& e) {
25611       {
25612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25613       };
25614     } catch (Dali::DaliException e) {
25615       {
25616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25617       };
25618     } catch (...) {
25619       {
25620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25621       };
25622     }
25623   }
25624   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
25625   return jresult;
25626 }
25627
25628
25629 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_position_get(void * jarg1) {
25630   void * jresult ;
25631   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
25632   Dali::Vector2 result;
25633
25634   arg1 = (Dali::PanGesture *)jarg1;
25635   {
25636     try {
25637       result = ((Dali::PanGesture const *)arg1)->GetPosition();
25638     } catch (std::out_of_range& e) {
25639       {
25640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25641       };
25642     } catch (std::exception& e) {
25643       {
25644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25645       };
25646     } catch (Dali::DaliException e) {
25647       {
25648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25649       };
25650     } catch (...) {
25651       {
25652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25653       };
25654     }
25655   }
25656   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
25657   return jresult;
25658 }
25659
25660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_get(void * jarg1) {
25661   void * jresult ;
25662   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
25663   Dali::Vector2 result;
25664
25665   arg1 = (Dali::PanGesture *)jarg1;
25666   {
25667     try {
25668       result = ((Dali::PanGesture const *)arg1)->GetScreenVelocity();
25669     } catch (std::out_of_range& e) {
25670       {
25671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25672       };
25673     } catch (std::exception& e) {
25674       {
25675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25676       };
25677     } catch (Dali::DaliException e) {
25678       {
25679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25680       };
25681     } catch (...) {
25682       {
25683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25684       };
25685     }
25686   }
25687   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
25688   return jresult;
25689 }
25690
25691
25692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_get(void * jarg1) {
25693   void * jresult ;
25694   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
25695   Dali::Vector2 result;
25696
25697   arg1 = (Dali::PanGesture *)jarg1;
25698   {
25699     try {
25700       result = ((Dali::PanGesture const *)arg1)->GetScreenDisplacement();
25701     } catch (std::out_of_range& e) {
25702       {
25703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25704       };
25705     } catch (std::exception& e) {
25706       {
25707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25708       };
25709     } catch (Dali::DaliException e) {
25710       {
25711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25712       };
25713     } catch (...) {
25714       {
25715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25716       };
25717     }
25718   }
25719   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
25720   return jresult;
25721 }
25722
25723
25724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_get(void * jarg1) {
25725   void * jresult ;
25726   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
25727   Dali::Vector2 result;
25728
25729   arg1 = (Dali::PanGesture *)jarg1;
25730   {
25731     try {
25732       result = ((Dali::PanGesture const *)arg1)->GetScreenPosition();
25733     } catch (std::out_of_range& e) {
25734       {
25735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25736       };
25737     } catch (std::exception& e) {
25738       {
25739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25740       };
25741     } catch (Dali::DaliException e) {
25742       {
25743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25744       };
25745     } catch (...) {
25746       {
25747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25748       };
25749     }
25750   }
25751   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
25752   return jresult;
25753 }
25754
25755
25756 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_get(void * jarg1) {
25757   unsigned int jresult ;
25758   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
25759   unsigned int result;
25760
25761   arg1 = (Dali::PanGesture *)jarg1;
25762   result = (unsigned int) ((arg1)->GetNumberOfTouches());
25763   jresult = result;
25764   return jresult;
25765 }
25766
25767
25768 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetSpeed(void * jarg1) {
25769   float jresult ;
25770   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
25771   float result;
25772
25773   arg1 = (Dali::PanGesture *)jarg1;
25774   {
25775     try {
25776       result = (float)((Dali::PanGesture const *)arg1)->GetSpeed();
25777     } CALL_CATCH_EXCEPTION(0);
25778   }
25779
25780   jresult = result;
25781   return jresult;
25782 }
25783
25784
25785 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetDistance(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)->GetDistance();
25794     } CALL_CATCH_EXCEPTION(0);
25795   }
25796
25797   jresult = result;
25798   return jresult;
25799 }
25800
25801
25802 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenSpeed(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)->GetScreenSpeed();
25811     } CALL_CATCH_EXCEPTION(0);
25812   }
25813
25814   jresult = result;
25815   return jresult;
25816 }
25817
25818
25819 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenDistance(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)->GetScreenDistance();
25828     } CALL_CATCH_EXCEPTION(0);
25829   }
25830
25831   jresult = result;
25832   return jresult;
25833 }
25834
25835
25836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_0() {
25837   void * jresult ;
25838   Dali::PinchGestureDetector *result = 0 ;
25839
25840   {
25841     try {
25842       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector();
25843     } CALL_CATCH_EXCEPTION(0);
25844   }
25845
25846   jresult = (void *)result;
25847   return jresult;
25848 }
25849
25850
25851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_New() {
25852   void * jresult ;
25853   Dali::PinchGestureDetector result;
25854
25855   {
25856     try {
25857       result = Dali::PinchGestureDetector::New();
25858     } CALL_CATCH_EXCEPTION(0);
25859   }
25860
25861   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
25862   return jresult;
25863 }
25864
25865
25866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DownCast(void * jarg1) {
25867   void * jresult ;
25868   Dali::BaseHandle arg1 ;
25869   Dali::BaseHandle *argp1 ;
25870   Dali::PinchGestureDetector result;
25871
25872   argp1 = (Dali::BaseHandle *)jarg1;
25873   if (!argp1) {
25874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25875     return 0;
25876   }
25877   arg1 = *argp1;
25878   {
25879     try {
25880       result = Dali::PinchGestureDetector::DownCast(arg1);
25881     } CALL_CATCH_EXCEPTION(0);
25882   }
25883
25884   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
25885   return jresult;
25886 }
25887
25888
25889 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetector(void * jarg1) {
25890   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
25891
25892   arg1 = (Dali::PinchGestureDetector *)jarg1;
25893   {
25894     try {
25895       delete arg1;
25896     } CALL_CATCH_EXCEPTION();
25897   }
25898
25899 }
25900
25901
25902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_1(void * jarg1) {
25903   void * jresult ;
25904   Dali::PinchGestureDetector *arg1 = 0 ;
25905   Dali::PinchGestureDetector *result = 0 ;
25906
25907   arg1 = (Dali::PinchGestureDetector *)jarg1;
25908   if (!arg1) {
25909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
25910     return 0;
25911   }
25912   {
25913     try {
25914       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1);
25915     } CALL_CATCH_EXCEPTION(0);
25916   }
25917
25918   jresult = (void *)result;
25919   return jresult;
25920 }
25921
25922
25923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_Assign(void * jarg1, void * jarg2) {
25924   void * jresult ;
25925   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
25926   Dali::PinchGestureDetector *arg2 = 0 ;
25927   Dali::PinchGestureDetector *result = 0 ;
25928
25929   arg1 = (Dali::PinchGestureDetector *)jarg1;
25930   arg2 = (Dali::PinchGestureDetector *)jarg2;
25931   if (!arg2) {
25932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
25933     return 0;
25934   }
25935   {
25936     try {
25937       result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2);
25938     } CALL_CATCH_EXCEPTION(0);
25939   }
25940
25941   jresult = (void *)result;
25942   return jresult;
25943 }
25944
25945
25946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DetectedSignal(void * jarg1) {
25947   void * jresult ;
25948   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
25949   Dali::PinchGestureDetector::DetectedSignalType *result = 0 ;
25950
25951   arg1 = (Dali::PinchGestureDetector *)jarg1;
25952   {
25953     try {
25954       result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
25955     } CALL_CATCH_EXCEPTION(0);
25956   }
25957
25958   jresult = (void *)result;
25959   return jresult;
25960 }
25961
25962
25963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_0() {
25964   void * jresult ;
25965   Dali::PinchGesture *result = 0 ;
25966
25967   {
25968     try {
25969       result = (Dali::PinchGesture *)new Dali::PinchGesture();
25970     } CALL_CATCH_EXCEPTION(0);
25971   }
25972
25973   jresult = (void *)result;
25974   return jresult;
25975 }
25976
25977
25978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_1(void * jarg1) {
25979   void * jresult ;
25980   Dali::PinchGesture *arg1 = 0 ;
25981   Dali::PinchGesture *result = 0 ;
25982
25983   arg1 = (Dali::PinchGesture *)jarg1;
25984   if (!arg1) {
25985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
25986     return 0;
25987   }
25988   {
25989     try {
25990       result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*arg1);
25991     } CALL_CATCH_EXCEPTION(0);
25992   }
25993
25994   jresult = (void *)result;
25995   return jresult;
25996 }
25997
25998
25999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_Assign(void * jarg1, void * jarg2) {
26000   void * jresult ;
26001   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
26002   Dali::PinchGesture *arg2 = 0 ;
26003   Dali::PinchGesture *result = 0 ;
26004
26005   arg1 = (Dali::PinchGesture *)jarg1;
26006   arg2 = (Dali::PinchGesture *)jarg2;
26007   if (!arg2) {
26008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
26009     return 0;
26010   }
26011   {
26012     try {
26013       result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2);
26014     } CALL_CATCH_EXCEPTION(0);
26015   }
26016
26017   jresult = (void *)result;
26018   return jresult;
26019 }
26020
26021
26022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGesture(void * jarg1) {
26023   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
26024
26025   arg1 = (Dali::PinchGesture *)jarg1;
26026   {
26027     try {
26028       delete arg1;
26029     } CALL_CATCH_EXCEPTION();
26030   }
26031
26032 }
26033
26034
26035 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_scale_get(void * jarg1) {
26036   float jresult ;
26037   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
26038   float result;
26039
26040   arg1 = (Dali::PinchGesture *)jarg1;
26041   result = (float) ((arg1)->GetScale());
26042   jresult = result;
26043   return jresult;
26044 }
26045
26046
26047 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_speed_get(void * jarg1) {
26048   float jresult ;
26049   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
26050   float result;
26051
26052   arg1 = (Dali::PinchGesture *)jarg1;
26053   result = (float) ((arg1)->GetSpeed());
26054   jresult = result;
26055   return jresult;
26056 }
26057
26058
26059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_get(void * jarg1) {
26060   void * jresult ;
26061   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
26062   Dali::Vector2 result;
26063
26064   arg1 = (Dali::PinchGesture *)jarg1;
26065   {
26066     try {
26067       result = ((Dali::PinchGesture const *)arg1)->GetScreenCenterPoint();
26068     } catch (std::out_of_range& e) {
26069       {
26070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26071       };
26072     } catch (std::exception& e) {
26073       {
26074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26075       };
26076     } catch (Dali::DaliException e) {
26077       {
26078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26079       };
26080     } catch (...) {
26081       {
26082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26083       };
26084     }
26085   }
26086   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
26087   return jresult;
26088 }
26089
26090
26091 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_get(void * jarg1) {
26092   void * jresult ;
26093   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
26094   Dali::Vector2 result;
26095
26096   arg1 = (Dali::PinchGesture *)jarg1;
26097   {
26098     try {
26099       result = ((Dali::PinchGesture const *)arg1)->GetLocalCenterPoint();
26100     } catch (std::out_of_range& e) {
26101       {
26102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26103       };
26104     } catch (std::exception& e) {
26105       {
26106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26107       };
26108     } catch (Dali::DaliException e) {
26109       {
26110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26111       };
26112     } catch (...) {
26113       {
26114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26115       };
26116     }
26117   }
26118   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
26119   return jresult;
26120 }
26121
26122
26123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_0() {
26124   void * jresult ;
26125   Dali::TapGestureDetector *result = 0 ;
26126
26127   {
26128     try {
26129       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector();
26130     } CALL_CATCH_EXCEPTION(0);
26131   }
26132
26133   jresult = (void *)result;
26134   return jresult;
26135 }
26136
26137
26138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_0() {
26139   void * jresult ;
26140   Dali::TapGestureDetector result;
26141
26142   {
26143     try {
26144       result = Dali::TapGestureDetector::New();
26145     } CALL_CATCH_EXCEPTION(0);
26146   }
26147
26148   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
26149   return jresult;
26150 }
26151
26152
26153 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_1(unsigned int jarg1) {
26154   void * jresult ;
26155   unsigned int arg1 ;
26156   Dali::TapGestureDetector result;
26157
26158   arg1 = (unsigned int)jarg1;
26159   {
26160     try {
26161       result = Dali::TapGestureDetector::New(arg1);
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_DownCast(void * jarg1) {
26171   void * jresult ;
26172   Dali::BaseHandle arg1 ;
26173   Dali::BaseHandle *argp1 ;
26174   Dali::TapGestureDetector result;
26175
26176   argp1 = (Dali::BaseHandle *)jarg1;
26177   if (!argp1) {
26178     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26179     return 0;
26180   }
26181   arg1 = *argp1;
26182   {
26183     try {
26184       result = Dali::TapGestureDetector::DownCast(arg1);
26185     } CALL_CATCH_EXCEPTION(0);
26186   }
26187
26188   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
26189   return jresult;
26190 }
26191
26192
26193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetector(void * jarg1) {
26194   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
26195
26196   arg1 = (Dali::TapGestureDetector *)jarg1;
26197   {
26198     try {
26199       delete arg1;
26200     } CALL_CATCH_EXCEPTION();
26201   }
26202
26203 }
26204
26205
26206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_1(void * jarg1) {
26207   void * jresult ;
26208   Dali::TapGestureDetector *arg1 = 0 ;
26209   Dali::TapGestureDetector *result = 0 ;
26210
26211   arg1 = (Dali::TapGestureDetector *)jarg1;
26212   if (!arg1) {
26213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
26214     return 0;
26215   }
26216   {
26217     try {
26218       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1);
26219     } CALL_CATCH_EXCEPTION(0);
26220   }
26221
26222   jresult = (void *)result;
26223   return jresult;
26224 }
26225
26226
26227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_Assign(void * jarg1, void * jarg2) {
26228   void * jresult ;
26229   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
26230   Dali::TapGestureDetector *arg2 = 0 ;
26231   Dali::TapGestureDetector *result = 0 ;
26232
26233   arg1 = (Dali::TapGestureDetector *)jarg1;
26234   arg2 = (Dali::TapGestureDetector *)jarg2;
26235   if (!arg2) {
26236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
26237     return 0;
26238   }
26239   {
26240     try {
26241       result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2);
26242     } CALL_CATCH_EXCEPTION(0);
26243   }
26244
26245   jresult = (void *)result;
26246   return jresult;
26247 }
26248
26249
26250 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) {
26251   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
26252   unsigned int arg2 ;
26253
26254   arg1 = (Dali::TapGestureDetector *)jarg1;
26255   arg2 = (unsigned int)jarg2;
26256   {
26257     try {
26258       (arg1)->SetMinimumTapsRequired(arg2);
26259     } CALL_CATCH_EXCEPTION();
26260   }
26261
26262 }
26263
26264
26265 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) {
26266   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
26267   unsigned int arg2 ;
26268
26269   arg1 = (Dali::TapGestureDetector *)jarg1;
26270   arg2 = (unsigned int)jarg2;
26271   {
26272     try {
26273       (arg1)->SetMaximumTapsRequired(arg2);
26274     } CALL_CATCH_EXCEPTION();
26275   }
26276
26277 }
26278
26279
26280 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) {
26281   unsigned int jresult ;
26282   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
26283   unsigned int result;
26284
26285   arg1 = (Dali::TapGestureDetector *)jarg1;
26286   {
26287     try {
26288       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired();
26289     } CALL_CATCH_EXCEPTION(0);
26290   }
26291
26292   jresult = result;
26293   return jresult;
26294 }
26295
26296
26297 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMaximumTapsRequired(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)->GetMaximumTapsRequired();
26306     } CALL_CATCH_EXCEPTION(0);
26307   }
26308
26309   jresult = result;
26310   return jresult;
26311 }
26312
26313
26314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DetectedSignal(void * jarg1) {
26315   void * jresult ;
26316   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
26317   Dali::TapGestureDetector::DetectedSignalType *result = 0 ;
26318
26319   arg1 = (Dali::TapGestureDetector *)jarg1;
26320   {
26321     try {
26322       result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
26323     } CALL_CATCH_EXCEPTION(0);
26324   }
26325
26326   jresult = (void *)result;
26327   return jresult;
26328 }
26329
26330
26331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_0() {
26332   void * jresult ;
26333   Dali::TapGesture *result = 0 ;
26334
26335   {
26336     try {
26337       result = (Dali::TapGesture *)new Dali::TapGesture();
26338     } CALL_CATCH_EXCEPTION(0);
26339   }
26340
26341   jresult = (void *)result;
26342   return jresult;
26343 }
26344
26345
26346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_1(void * jarg1) {
26347   void * jresult ;
26348   Dali::TapGesture *arg1 = 0 ;
26349   Dali::TapGesture *result = 0 ;
26350
26351   arg1 = (Dali::TapGesture *)jarg1;
26352   if (!arg1) {
26353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
26354     return 0;
26355   }
26356   {
26357     try {
26358       result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1);
26359     } CALL_CATCH_EXCEPTION(0);
26360   }
26361
26362   jresult = (void *)result;
26363   return jresult;
26364 }
26365
26366
26367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_Assign(void * jarg1, void * jarg2) {
26368   void * jresult ;
26369   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
26370   Dali::TapGesture *arg2 = 0 ;
26371   Dali::TapGesture *result = 0 ;
26372
26373   arg1 = (Dali::TapGesture *)jarg1;
26374   arg2 = (Dali::TapGesture *)jarg2;
26375   if (!arg2) {
26376     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
26377     return 0;
26378   }
26379   {
26380     try {
26381       result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2);
26382     } CALL_CATCH_EXCEPTION(0);
26383   }
26384
26385   jresult = (void *)result;
26386   return jresult;
26387 }
26388
26389
26390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGesture(void * jarg1) {
26391   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
26392
26393   arg1 = (Dali::TapGesture *)jarg1;
26394   {
26395     try {
26396       delete arg1;
26397     } CALL_CATCH_EXCEPTION();
26398   }
26399
26400 }
26401
26402
26403 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_get(void * jarg1) {
26404   unsigned int jresult ;
26405   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
26406   unsigned int result;
26407
26408   arg1 = (Dali::TapGesture *)jarg1;
26409   result = (unsigned int) ((arg1)->GetNumberOfTaps());
26410   jresult = result;
26411   return jresult;
26412 }
26413
26414 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_get(void * jarg1) {
26415   unsigned int jresult ;
26416   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
26417   unsigned int result;
26418
26419   arg1 = (Dali::TapGesture *)jarg1;
26420   result = (unsigned int) ((arg1)->GetNumberOfTouches());
26421   jresult = result;
26422   return jresult;
26423 }
26424
26425
26426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_get(void * jarg1) {
26427   void * jresult ;
26428   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
26429   Dali::Vector2 result;
26430
26431   arg1 = (Dali::TapGesture *)jarg1;
26432   {
26433     try {
26434       result = ((Dali::TapGesture const *)arg1)->GetScreenPoint();
26435     } catch (std::out_of_range& e) {
26436       {
26437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26438       };
26439     } catch (std::exception& e) {
26440       {
26441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26442       };
26443     } catch (Dali::DaliException e) {
26444       {
26445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26446       };
26447     } catch (...) {
26448       {
26449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26450       };
26451     }
26452   }
26453   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
26454   return jresult;
26455 }
26456
26457
26458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_get(void * jarg1) {
26459   void * jresult ;
26460   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
26461   Dali::Vector2 result;
26462
26463   arg1 = (Dali::TapGesture *)jarg1;
26464   {
26465     try {
26466       result = ((Dali::TapGesture const *)arg1)->GetLocalPoint();
26467     } catch (std::out_of_range& e) {
26468       {
26469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26470       };
26471     } catch (std::exception& e) {
26472       {
26473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26474       };
26475     } catch (Dali::DaliException e) {
26476       {
26477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26478       };
26479     } catch (...) {
26480       {
26481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26482       };
26483     }
26484   }
26485   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
26486   return jresult;
26487 }
26488
26489
26490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_0() {
26491   void * jresult ;
26492   Dali::AlphaFunction *result = 0 ;
26493
26494   {
26495     try {
26496       result = (Dali::AlphaFunction *)new Dali::AlphaFunction();
26497     } CALL_CATCH_EXCEPTION(0);
26498   }
26499
26500   jresult = (void *)result;
26501   return jresult;
26502 }
26503
26504
26505 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_1(int jarg1) {
26506   void * jresult ;
26507   Dali::AlphaFunction::BuiltinFunction arg1 ;
26508   Dali::AlphaFunction *result = 0 ;
26509
26510   arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1;
26511   {
26512     try {
26513       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
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_2(void * jarg1) {
26523   void * jresult ;
26524   Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ;
26525   Dali::AlphaFunction *result = 0 ;
26526
26527   arg1 = (Dali::AlphaFunctionPrototype)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_3(void * jarg1, void * jarg2) {
26540   void * jresult ;
26541   Dali::Vector2 *arg1 = 0 ;
26542   Dali::Vector2 *arg2 = 0 ;
26543   Dali::AlphaFunction *result = 0 ;
26544
26545   arg1 = (Dali::Vector2 *)jarg1;
26546   if (!arg1) {
26547     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
26548     return 0;
26549   }
26550   arg2 = (Dali::Vector2 *)jarg2;
26551   if (!arg2) {
26552     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
26553     return 0;
26554   }
26555   {
26556     try {
26557       result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
26558     } CALL_CATCH_EXCEPTION(0);
26559   }
26560
26561   jresult = (void *)result;
26562   return jresult;
26563 }
26564
26565
26566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBezierControlPoints(void * jarg1) {
26567   void * jresult ;
26568   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
26569   Dali::Vector4 result;
26570
26571   arg1 = (Dali::AlphaFunction *)jarg1;
26572   {
26573     try {
26574       result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints();
26575     } CALL_CATCH_EXCEPTION(0);
26576   }
26577
26578   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
26579   return jresult;
26580 }
26581
26582
26583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetCustomFunction(void * jarg1) {
26584   void * jresult ;
26585   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
26586   Dali::AlphaFunctionPrototype result;
26587
26588   arg1 = (Dali::AlphaFunction *)jarg1;
26589   {
26590     try {
26591       result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction();
26592     } CALL_CATCH_EXCEPTION(0);
26593   }
26594
26595   jresult = (void *)result;
26596   return jresult;
26597 }
26598
26599
26600 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBuiltinFunction(void * jarg1) {
26601   int jresult ;
26602   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
26603   Dali::AlphaFunction::BuiltinFunction result;
26604
26605   arg1 = (Dali::AlphaFunction *)jarg1;
26606   {
26607     try {
26608       result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction();
26609     } CALL_CATCH_EXCEPTION(0);
26610   }
26611
26612   jresult = (int)result;
26613   return jresult;
26614 }
26615
26616
26617 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetMode(void * jarg1) {
26618   int jresult ;
26619   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
26620   Dali::AlphaFunction::Mode result;
26621
26622   arg1 = (Dali::AlphaFunction *)jarg1;
26623   {
26624     try {
26625       result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode();
26626     } CALL_CATCH_EXCEPTION(0);
26627   }
26628
26629   jresult = (int)result;
26630   return jresult;
26631 }
26632
26633
26634 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AlphaFunction(void * jarg1) {
26635   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
26636
26637   arg1 = (Dali::AlphaFunction *)jarg1;
26638   {
26639     try {
26640       delete arg1;
26641     } CALL_CATCH_EXCEPTION();
26642   }
26643
26644 }
26645
26646
26647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_New() {
26648   void * jresult ;
26649   Dali::KeyFrames result;
26650
26651   {
26652     try {
26653       result = Dali::KeyFrames::New();
26654     } CALL_CATCH_EXCEPTION(0);
26655   }
26656
26657   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
26658   return jresult;
26659 }
26660
26661
26662 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_DownCast(void * jarg1) {
26663   void * jresult ;
26664   Dali::BaseHandle arg1 ;
26665   Dali::BaseHandle *argp1 ;
26666   Dali::KeyFrames result;
26667
26668   argp1 = (Dali::BaseHandle *)jarg1;
26669   if (!argp1) {
26670     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26671     return 0;
26672   }
26673   arg1 = *argp1;
26674   {
26675     try {
26676       result = Dali::KeyFrames::DownCast(arg1);
26677     } CALL_CATCH_EXCEPTION(0);
26678   }
26679
26680   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
26681   return jresult;
26682 }
26683
26684
26685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_0() {
26686   void * jresult ;
26687   Dali::KeyFrames *result = 0 ;
26688
26689   {
26690     try {
26691       result = (Dali::KeyFrames *)new Dali::KeyFrames();
26692     } CALL_CATCH_EXCEPTION(0);
26693   }
26694
26695   jresult = (void *)result;
26696   return jresult;
26697 }
26698
26699
26700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyFrames(void * jarg1) {
26701   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
26702
26703   arg1 = (Dali::KeyFrames *)jarg1;
26704   {
26705     try {
26706       delete arg1;
26707     } CALL_CATCH_EXCEPTION();
26708   }
26709
26710 }
26711
26712
26713 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_1(void * jarg1) {
26714   void * jresult ;
26715   Dali::KeyFrames *arg1 = 0 ;
26716   Dali::KeyFrames *result = 0 ;
26717
26718   arg1 = (Dali::KeyFrames *)jarg1;
26719   if (!arg1) {
26720     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
26721     return 0;
26722   }
26723   {
26724     try {
26725       result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1);
26726     } CALL_CATCH_EXCEPTION(0);
26727   }
26728
26729   jresult = (void *)result;
26730   return jresult;
26731 }
26732
26733
26734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_Assign(void * jarg1, void * jarg2) {
26735   void * jresult ;
26736   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
26737   Dali::KeyFrames *arg2 = 0 ;
26738   Dali::KeyFrames *result = 0 ;
26739
26740   arg1 = (Dali::KeyFrames *)jarg1;
26741   arg2 = (Dali::KeyFrames *)jarg2;
26742   if (!arg2) {
26743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
26744     return 0;
26745   }
26746   {
26747     try {
26748       result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2);
26749     } CALL_CATCH_EXCEPTION(0);
26750   }
26751
26752   jresult = (void *)result;
26753   return jresult;
26754 }
26755
26756
26757 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_KeyFrames_GetType(void * jarg1) {
26758   int jresult ;
26759   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
26760   Dali::Property::Type result;
26761
26762   arg1 = (Dali::KeyFrames *)jarg1;
26763   {
26764     try {
26765       result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType();
26766     } CALL_CATCH_EXCEPTION(0);
26767   }
26768
26769   jresult = (int)result;
26770   return jresult;
26771 }
26772
26773
26774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) {
26775   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
26776   float arg2 ;
26777   Dali::Property::Value arg3 ;
26778   Dali::Property::Value *argp3 ;
26779
26780   arg1 = (Dali::KeyFrames *)jarg1;
26781   arg2 = (float)jarg2;
26782   argp3 = (Dali::Property::Value *)jarg3;
26783   if (!argp3) {
26784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
26785     return ;
26786   }
26787   arg3 = *argp3;
26788   {
26789     try {
26790       (arg1)->Add(arg2,arg3);
26791     } CALL_CATCH_EXCEPTION();
26792   }
26793
26794 }
26795
26796
26797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
26798   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
26799   float arg2 ;
26800   Dali::Property::Value arg3 ;
26801   Dali::AlphaFunction arg4 ;
26802   Dali::Property::Value *argp3 ;
26803   Dali::AlphaFunction *argp4 ;
26804
26805   arg1 = (Dali::KeyFrames *)jarg1;
26806   arg2 = (float)jarg2;
26807   argp3 = (Dali::Property::Value *)jarg3;
26808   if (!argp3) {
26809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
26810     return ;
26811   }
26812   arg3 = *argp3;
26813   argp4 = (Dali::AlphaFunction *)jarg4;
26814   if (!argp4) {
26815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
26816     return ;
26817   }
26818   arg4 = *argp4;
26819   {
26820     try {
26821       (arg1)->Add(arg2,arg3,arg4);
26822     } CALL_CATCH_EXCEPTION();
26823   }
26824
26825 }
26826
26827
26828 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_POINTS_get() {
26829   int jresult ;
26830   int result;
26831
26832   result = (int)Dali::Path::Property::POINTS;
26833   jresult = (int)result;
26834   return jresult;
26835 }
26836
26837
26838 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_CONTROL_POINTS_get() {
26839   int jresult ;
26840   int result;
26841
26842   result = (int)Dali::Path::Property::CONTROL_POINTS;
26843   jresult = (int)result;
26844   return jresult;
26845 }
26846
26847
26848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path_Property() {
26849   void * jresult ;
26850   Dali::Path::Property *result = 0 ;
26851
26852   {
26853     try {
26854       result = (Dali::Path::Property *)new Dali::Path::Property();
26855     } CALL_CATCH_EXCEPTION(0);
26856   }
26857
26858   jresult = (void *)result;
26859   return jresult;
26860 }
26861
26862
26863 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path_Property(void * jarg1) {
26864   Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ;
26865
26866   arg1 = (Dali::Path::Property *)jarg1;
26867   {
26868     try {
26869       delete arg1;
26870     } CALL_CATCH_EXCEPTION();
26871   }
26872
26873 }
26874
26875
26876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_New() {
26877   void * jresult ;
26878   Dali::Path result;
26879
26880   {
26881     try {
26882       result = Dali::Path::New();
26883     } CALL_CATCH_EXCEPTION(0);
26884   }
26885
26886   jresult = new Dali::Path((const Dali::Path &)result);
26887   return jresult;
26888 }
26889
26890
26891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_DownCast(void * jarg1) {
26892   void * jresult ;
26893   Dali::BaseHandle arg1 ;
26894   Dali::BaseHandle *argp1 ;
26895   Dali::Path result;
26896
26897   argp1 = (Dali::BaseHandle *)jarg1;
26898   if (!argp1) {
26899     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26900     return 0;
26901   }
26902   arg1 = *argp1;
26903   {
26904     try {
26905       result = Dali::Path::DownCast(arg1);
26906     } CALL_CATCH_EXCEPTION(0);
26907   }
26908
26909   jresult = new Dali::Path((const Dali::Path &)result);
26910   return jresult;
26911 }
26912
26913
26914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_0() {
26915   void * jresult ;
26916   Dali::Path *result = 0 ;
26917
26918   {
26919     try {
26920       result = (Dali::Path *)new Dali::Path();
26921     } CALL_CATCH_EXCEPTION(0);
26922   }
26923
26924   jresult = (void *)result;
26925   return jresult;
26926 }
26927
26928
26929 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path(void * jarg1) {
26930   Dali::Path *arg1 = (Dali::Path *) 0 ;
26931
26932   arg1 = (Dali::Path *)jarg1;
26933   {
26934     try {
26935       delete arg1;
26936     } CALL_CATCH_EXCEPTION();
26937   }
26938
26939 }
26940
26941
26942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_1(void * jarg1) {
26943   void * jresult ;
26944   Dali::Path *arg1 = 0 ;
26945   Dali::Path *result = 0 ;
26946
26947   arg1 = (Dali::Path *)jarg1;
26948   if (!arg1) {
26949     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
26950     return 0;
26951   }
26952   {
26953     try {
26954       result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1);
26955     } CALL_CATCH_EXCEPTION(0);
26956   }
26957
26958   jresult = (void *)result;
26959   return jresult;
26960 }
26961
26962
26963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_Assign(void * jarg1, void * jarg2) {
26964   void * jresult ;
26965   Dali::Path *arg1 = (Dali::Path *) 0 ;
26966   Dali::Path *arg2 = 0 ;
26967   Dali::Path *result = 0 ;
26968
26969   arg1 = (Dali::Path *)jarg1;
26970   arg2 = (Dali::Path *)jarg2;
26971   if (!arg2) {
26972     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
26973     return 0;
26974   }
26975   {
26976     try {
26977       result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2);
26978     } CALL_CATCH_EXCEPTION(0);
26979   }
26980
26981   jresult = (void *)result;
26982   return jresult;
26983 }
26984
26985
26986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddPoint(void * jarg1, void * jarg2) {
26987   Dali::Path *arg1 = (Dali::Path *) 0 ;
26988   Dali::Vector3 *arg2 = 0 ;
26989
26990   arg1 = (Dali::Path *)jarg1;
26991   arg2 = (Dali::Vector3 *)jarg2;
26992   if (!arg2) {
26993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
26994     return ;
26995   }
26996   {
26997     try {
26998       (arg1)->AddPoint((Dali::Vector3 const &)*arg2);
26999     } CALL_CATCH_EXCEPTION();
27000   }
27001
27002 }
27003
27004
27005 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddControlPoint(void * jarg1, void * jarg2) {
27006   Dali::Path *arg1 = (Dali::Path *) 0 ;
27007   Dali::Vector3 *arg2 = 0 ;
27008
27009   arg1 = (Dali::Path *)jarg1;
27010   arg2 = (Dali::Vector3 *)jarg2;
27011   if (!arg2) {
27012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
27013     return ;
27014   }
27015   {
27016     try {
27017       (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2);
27018     } CALL_CATCH_EXCEPTION();
27019   }
27020
27021 }
27022
27023
27024 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_GenerateControlPoints(void * jarg1, float jarg2) {
27025   Dali::Path *arg1 = (Dali::Path *) 0 ;
27026   float arg2 ;
27027
27028   arg1 = (Dali::Path *)jarg1;
27029   arg2 = (float)jarg2;
27030   {
27031     try {
27032       (arg1)->GenerateControlPoints(arg2);
27033     } CALL_CATCH_EXCEPTION();
27034   }
27035
27036 }
27037
27038
27039 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
27040   Dali::Path *arg1 = (Dali::Path *) 0 ;
27041   float arg2 ;
27042   Dali::Vector3 *arg3 = 0 ;
27043   Dali::Vector3 *arg4 = 0 ;
27044
27045   arg1 = (Dali::Path *)jarg1;
27046   arg2 = (float)jarg2;
27047   arg3 = (Dali::Vector3 *)jarg3;
27048   if (!arg3) {
27049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
27050     return ;
27051   }
27052   arg4 = (Dali::Vector3 *)jarg4;
27053   if (!arg4) {
27054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
27055     return ;
27056   }
27057   {
27058     try {
27059       ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4);
27060     } CALL_CATCH_EXCEPTION();
27061   }
27062
27063 }
27064
27065
27066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetPoint(void * jarg1, unsigned long jarg2) {
27067   void * jresult ;
27068   Dali::Path *arg1 = (Dali::Path *) 0 ;
27069   size_t arg2 ;
27070   Dali::Vector3 *result = 0 ;
27071
27072   arg1 = (Dali::Path *)jarg1;
27073   arg2 = (size_t)jarg2;
27074   {
27075     try {
27076       result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2);
27077     } CALL_CATCH_EXCEPTION(0);
27078   }
27079
27080   jresult = (void *)result;
27081   return jresult;
27082 }
27083
27084
27085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetControlPoint(void * jarg1, unsigned long jarg2) {
27086   void * jresult ;
27087   Dali::Path *arg1 = (Dali::Path *) 0 ;
27088   size_t arg2 ;
27089   Dali::Vector3 *result = 0 ;
27090
27091   arg1 = (Dali::Path *)jarg1;
27092   arg2 = (size_t)jarg2;
27093   {
27094     try {
27095       result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2);
27096     } CALL_CATCH_EXCEPTION(0);
27097   }
27098
27099   jresult = (void *)result;
27100   return jresult;
27101 }
27102
27103
27104 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Path_GetPointCount(void * jarg1) {
27105   unsigned long jresult ;
27106   Dali::Path *arg1 = (Dali::Path *) 0 ;
27107   size_t result;
27108
27109   arg1 = (Dali::Path *)jarg1;
27110   {
27111     try {
27112       result = ((Dali::Path const *)arg1)->GetPointCount();
27113     } CALL_CATCH_EXCEPTION(0);
27114   }
27115
27116   jresult = (unsigned long)result;
27117   return jresult;
27118 }
27119
27120
27121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_0(float jarg1) {
27122   void * jresult ;
27123   float arg1 ;
27124   Dali::TimePeriod *result = 0 ;
27125
27126   arg1 = (float)jarg1;
27127   {
27128     try {
27129       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1);
27130     } CALL_CATCH_EXCEPTION(0);
27131   }
27132
27133   jresult = (void *)result;
27134   return jresult;
27135 }
27136
27137
27138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_1(float jarg1, float jarg2) {
27139   void * jresult ;
27140   float arg1 ;
27141   float arg2 ;
27142   Dali::TimePeriod *result = 0 ;
27143
27144   arg1 = (float)jarg1;
27145   arg2 = (float)jarg2;
27146   {
27147     try {
27148       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2);
27149     } CALL_CATCH_EXCEPTION(0);
27150   }
27151
27152   jresult = (void *)result;
27153   return jresult;
27154 }
27155
27156
27157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimePeriod(void * jarg1) {
27158   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
27159
27160   arg1 = (Dali::TimePeriod *)jarg1;
27161   {
27162     try {
27163       delete arg1;
27164     } CALL_CATCH_EXCEPTION();
27165   }
27166
27167 }
27168
27169
27170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) {
27171   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
27172   float arg2 ;
27173
27174   arg1 = (Dali::TimePeriod *)jarg1;
27175   arg2 = (float)jarg2;
27176   if (arg1) (arg1)->delaySeconds = arg2;
27177 }
27178
27179
27180 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_get(void * jarg1) {
27181   float jresult ;
27182   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
27183   float result;
27184
27185   arg1 = (Dali::TimePeriod *)jarg1;
27186   result = (float) ((arg1)->delaySeconds);
27187   jresult = result;
27188   return jresult;
27189 }
27190
27191
27192 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) {
27193   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
27194   float arg2 ;
27195
27196   arg1 = (Dali::TimePeriod *)jarg1;
27197   arg2 = (float)jarg2;
27198   if (arg1) (arg1)->durationSeconds = arg2;
27199 }
27200
27201
27202 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_get(void * jarg1) {
27203   float jresult ;
27204   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
27205   float result;
27206
27207   arg1 = (Dali::TimePeriod *)jarg1;
27208   result = (float) ((arg1)->durationSeconds);
27209   jresult = result;
27210   return jresult;
27211 }
27212
27213 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_VALUE_get() {
27214   int jresult ;
27215   int result;
27216
27217   result = (int)Dali::LinearConstrainer::Property::VALUE;
27218   jresult = (int)result;
27219   return jresult;
27220 }
27221
27222
27223 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_PROGRESS_get() {
27224   int jresult ;
27225   int result;
27226
27227   result = (int)Dali::LinearConstrainer::Property::PROGRESS;
27228   jresult = (int)result;
27229   return jresult;
27230 }
27231
27232
27233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer_Property() {
27234   void * jresult ;
27235   Dali::LinearConstrainer::Property *result = 0 ;
27236
27237   {
27238     try {
27239       result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property();
27240     } CALL_CATCH_EXCEPTION(0);
27241   }
27242
27243   jresult = (void *)result;
27244   return jresult;
27245 }
27246
27247
27248 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer_Property(void * jarg1) {
27249   Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ;
27250
27251   arg1 = (Dali::LinearConstrainer::Property *)jarg1;
27252   {
27253     try {
27254       delete arg1;
27255     } CALL_CATCH_EXCEPTION();
27256   }
27257
27258 }
27259
27260
27261 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_New() {
27262   void * jresult ;
27263   Dali::LinearConstrainer result;
27264
27265   {
27266     try {
27267       result = Dali::LinearConstrainer::New();
27268     } CALL_CATCH_EXCEPTION(0);
27269   }
27270
27271   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
27272   return jresult;
27273 }
27274
27275
27276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_DownCast(void * jarg1) {
27277   void * jresult ;
27278   Dali::BaseHandle arg1 ;
27279   Dali::BaseHandle *argp1 ;
27280   Dali::LinearConstrainer result;
27281
27282   argp1 = (Dali::BaseHandle *)jarg1;
27283   if (!argp1) {
27284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27285     return 0;
27286   }
27287   arg1 = *argp1;
27288   {
27289     try {
27290       result = Dali::LinearConstrainer::DownCast(arg1);
27291     } CALL_CATCH_EXCEPTION(0);
27292   }
27293
27294   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
27295   return jresult;
27296 }
27297
27298
27299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_0() {
27300   void * jresult ;
27301   Dali::LinearConstrainer *result = 0 ;
27302
27303   {
27304     try {
27305       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer();
27306     } CALL_CATCH_EXCEPTION(0);
27307   }
27308
27309   jresult = (void *)result;
27310   return jresult;
27311 }
27312
27313
27314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer(void * jarg1) {
27315   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
27316
27317   arg1 = (Dali::LinearConstrainer *)jarg1;
27318   {
27319     try {
27320       delete arg1;
27321     } CALL_CATCH_EXCEPTION();
27322   }
27323
27324 }
27325
27326
27327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_1(void * jarg1) {
27328   void * jresult ;
27329   Dali::LinearConstrainer *arg1 = 0 ;
27330   Dali::LinearConstrainer *result = 0 ;
27331
27332   arg1 = (Dali::LinearConstrainer *)jarg1;
27333   if (!arg1) {
27334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
27335     return 0;
27336   }
27337   {
27338     try {
27339       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1);
27340     } CALL_CATCH_EXCEPTION(0);
27341   }
27342
27343   jresult = (void *)result;
27344   return jresult;
27345 }
27346
27347
27348 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_Assign(void * jarg1, void * jarg2) {
27349   void * jresult ;
27350   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
27351   Dali::LinearConstrainer *arg2 = 0 ;
27352   Dali::LinearConstrainer *result = 0 ;
27353
27354   arg1 = (Dali::LinearConstrainer *)jarg1;
27355   arg2 = (Dali::LinearConstrainer *)jarg2;
27356   if (!arg2) {
27357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
27358     return 0;
27359   }
27360   {
27361     try {
27362       result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2);
27363     } CALL_CATCH_EXCEPTION(0);
27364   }
27365
27366   jresult = (void *)result;
27367   return jresult;
27368 }
27369
27370
27371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
27372   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
27373   SwigValueWrapper< Dali::Property > arg2 ;
27374   SwigValueWrapper< Dali::Property > arg3 ;
27375   Dali::Vector2 *arg4 = 0 ;
27376   Dali::Vector2 *arg5 = 0 ;
27377   Dali::Property *argp2 ;
27378   Dali::Property *argp3 ;
27379
27380   arg1 = (Dali::LinearConstrainer *)jarg1;
27381   argp2 = (Dali::Property *)jarg2;
27382   if (!argp2) {
27383     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
27384     return ;
27385   }
27386   arg2 = *argp2;
27387   argp3 = (Dali::Property *)jarg3;
27388   if (!argp3) {
27389     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
27390     return ;
27391   }
27392   arg3 = *argp3;
27393   arg4 = (Dali::Vector2 *)jarg4;
27394   if (!arg4) {
27395     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
27396     return ;
27397   }
27398   arg5 = (Dali::Vector2 *)jarg5;
27399   if (!arg5) {
27400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
27401     return ;
27402   }
27403   {
27404     try {
27405       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
27406     } CALL_CATCH_EXCEPTION();
27407   }
27408
27409 }
27410
27411
27412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
27413   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
27414   SwigValueWrapper< Dali::Property > arg2 ;
27415   SwigValueWrapper< Dali::Property > arg3 ;
27416   Dali::Vector2 *arg4 = 0 ;
27417   Dali::Property *argp2 ;
27418   Dali::Property *argp3 ;
27419
27420   arg1 = (Dali::LinearConstrainer *)jarg1;
27421   argp2 = (Dali::Property *)jarg2;
27422   if (!argp2) {
27423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
27424     return ;
27425   }
27426   arg2 = *argp2;
27427   argp3 = (Dali::Property *)jarg3;
27428   if (!argp3) {
27429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
27430     return ;
27431   }
27432   arg3 = *argp3;
27433   arg4 = (Dali::Vector2 *)jarg4;
27434   if (!arg4) {
27435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
27436     return ;
27437   }
27438   {
27439     try {
27440       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
27441     } CALL_CATCH_EXCEPTION();
27442   }
27443
27444 }
27445
27446
27447 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Remove(void * jarg1, void * jarg2) {
27448   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
27449   Dali::Handle *arg2 = 0 ;
27450
27451   arg1 = (Dali::LinearConstrainer *)jarg1;
27452   arg2 = (Dali::Handle *)jarg2;
27453   if (!arg2) {
27454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
27455     return ;
27456   }
27457   {
27458     try {
27459       (arg1)->Remove(*arg2);
27460     } CALL_CATCH_EXCEPTION();
27461   }
27462
27463 }
27464
27465
27466 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_FORWARD_get() {
27467   int jresult ;
27468   int result;
27469
27470   result = (int)Dali::PathConstrainer::Property::FORWARD;
27471   jresult = (int)result;
27472   return jresult;
27473 }
27474
27475
27476 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_POINTS_get() {
27477   int jresult ;
27478   int result;
27479
27480   result = (int)Dali::PathConstrainer::Property::POINTS;
27481   jresult = (int)result;
27482   return jresult;
27483 }
27484
27485
27486 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_CONTROL_POINTS_get() {
27487   int jresult ;
27488   int result;
27489
27490   result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS;
27491   jresult = (int)result;
27492   return jresult;
27493 }
27494
27495
27496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer_Property() {
27497   void * jresult ;
27498   Dali::PathConstrainer::Property *result = 0 ;
27499
27500   {
27501     try {
27502       result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property();
27503     } CALL_CATCH_EXCEPTION(0);
27504   }
27505
27506   jresult = (void *)result;
27507   return jresult;
27508 }
27509
27510
27511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer_Property(void * jarg1) {
27512   Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ;
27513
27514   arg1 = (Dali::PathConstrainer::Property *)jarg1;
27515   {
27516     try {
27517       delete arg1;
27518     } CALL_CATCH_EXCEPTION();
27519   }
27520
27521 }
27522
27523
27524 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_New() {
27525   void * jresult ;
27526   Dali::PathConstrainer result;
27527
27528   {
27529     try {
27530       result = Dali::PathConstrainer::New();
27531     } CALL_CATCH_EXCEPTION(0);
27532   }
27533
27534   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
27535   return jresult;
27536 }
27537
27538
27539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_DownCast(void * jarg1) {
27540   void * jresult ;
27541   Dali::BaseHandle arg1 ;
27542   Dali::BaseHandle *argp1 ;
27543   Dali::PathConstrainer result;
27544
27545   argp1 = (Dali::BaseHandle *)jarg1;
27546   if (!argp1) {
27547     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27548     return 0;
27549   }
27550   arg1 = *argp1;
27551   {
27552     try {
27553       result = Dali::PathConstrainer::DownCast(arg1);
27554     } CALL_CATCH_EXCEPTION(0);
27555   }
27556
27557   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
27558   return jresult;
27559 }
27560
27561
27562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_0() {
27563   void * jresult ;
27564   Dali::PathConstrainer *result = 0 ;
27565
27566   {
27567     try {
27568       result = (Dali::PathConstrainer *)new Dali::PathConstrainer();
27569     } CALL_CATCH_EXCEPTION(0);
27570   }
27571
27572   jresult = (void *)result;
27573   return jresult;
27574 }
27575
27576
27577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer(void * jarg1) {
27578   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
27579
27580   arg1 = (Dali::PathConstrainer *)jarg1;
27581   {
27582     try {
27583       delete arg1;
27584     } CALL_CATCH_EXCEPTION();
27585   }
27586
27587 }
27588
27589
27590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_1(void * jarg1) {
27591   void * jresult ;
27592   Dali::PathConstrainer *arg1 = 0 ;
27593   Dali::PathConstrainer *result = 0 ;
27594
27595   arg1 = (Dali::PathConstrainer *)jarg1;
27596   if (!arg1) {
27597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
27598     return 0;
27599   }
27600   {
27601     try {
27602       result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1);
27603     } CALL_CATCH_EXCEPTION(0);
27604   }
27605
27606   jresult = (void *)result;
27607   return jresult;
27608 }
27609
27610
27611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_Assign(void * jarg1, void * jarg2) {
27612   void * jresult ;
27613   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
27614   Dali::PathConstrainer *arg2 = 0 ;
27615   Dali::PathConstrainer *result = 0 ;
27616
27617   arg1 = (Dali::PathConstrainer *)jarg1;
27618   arg2 = (Dali::PathConstrainer *)jarg2;
27619   if (!arg2) {
27620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
27621     return 0;
27622   }
27623   {
27624     try {
27625       result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2);
27626     } CALL_CATCH_EXCEPTION(0);
27627   }
27628
27629   jresult = (void *)result;
27630   return jresult;
27631 }
27632
27633
27634 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
27635   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
27636   SwigValueWrapper< Dali::Property > arg2 ;
27637   SwigValueWrapper< Dali::Property > arg3 ;
27638   Dali::Vector2 *arg4 = 0 ;
27639   Dali::Vector2 *arg5 = 0 ;
27640   Dali::Property *argp2 ;
27641   Dali::Property *argp3 ;
27642
27643   arg1 = (Dali::PathConstrainer *)jarg1;
27644   argp2 = (Dali::Property *)jarg2;
27645   if (!argp2) {
27646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
27647     return ;
27648   }
27649   arg2 = *argp2;
27650   argp3 = (Dali::Property *)jarg3;
27651   if (!argp3) {
27652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
27653     return ;
27654   }
27655   arg3 = *argp3;
27656   arg4 = (Dali::Vector2 *)jarg4;
27657   if (!arg4) {
27658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
27659     return ;
27660   }
27661   arg5 = (Dali::Vector2 *)jarg5;
27662   if (!arg5) {
27663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
27664     return ;
27665   }
27666   {
27667     try {
27668       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
27669     } CALL_CATCH_EXCEPTION();
27670   }
27671
27672 }
27673
27674
27675 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
27676   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
27677   SwigValueWrapper< Dali::Property > arg2 ;
27678   SwigValueWrapper< Dali::Property > arg3 ;
27679   Dali::Vector2 *arg4 = 0 ;
27680   Dali::Property *argp2 ;
27681   Dali::Property *argp3 ;
27682
27683   arg1 = (Dali::PathConstrainer *)jarg1;
27684   argp2 = (Dali::Property *)jarg2;
27685   if (!argp2) {
27686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
27687     return ;
27688   }
27689   arg2 = *argp2;
27690   argp3 = (Dali::Property *)jarg3;
27691   if (!argp3) {
27692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
27693     return ;
27694   }
27695   arg3 = *argp3;
27696   arg4 = (Dali::Vector2 *)jarg4;
27697   if (!arg4) {
27698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
27699     return ;
27700   }
27701   {
27702     try {
27703       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
27704     } CALL_CATCH_EXCEPTION();
27705   }
27706
27707 }
27708
27709
27710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Remove(void * jarg1, void * jarg2) {
27711   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
27712   Dali::Handle *arg2 = 0 ;
27713
27714   arg1 = (Dali::PathConstrainer *)jarg1;
27715   arg2 = (Dali::Handle *)jarg2;
27716   if (!arg2) {
27717     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
27718     return ;
27719   }
27720   {
27721     try {
27722       (arg1)->Remove(*arg2);
27723     } CALL_CATCH_EXCEPTION();
27724   }
27725
27726 }
27727
27728
27729 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FittingModeDefault_get() {
27730   int jresult ;
27731   Dali::FittingMode::Type result;
27732
27733   result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT;
27734   jresult = (int)result;
27735   return jresult;
27736 }
27737
27738
27739 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DEFAULT_get() {
27740   int jresult ;
27741   Dali::SamplingMode::Type result;
27742
27743   result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT;
27744   jresult = (int)result;
27745   return jresult;
27746 }
27747
27748
27749 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_CreateResource(void * jarg1) {
27750   unsigned int jresult ;
27751   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
27752   bool result;
27753
27754   arg1 = (Dali::NativeImageInterface *)jarg1;
27755   {
27756     try {
27757       result = (bool)(arg1)->CreateResource();
27758     } CALL_CATCH_EXCEPTION(0);
27759   }
27760
27761   jresult = result;
27762   return jresult;
27763 }
27764
27765
27766 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_DestroyResource(void * jarg1) {
27767   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
27768
27769   arg1 = (Dali::NativeImageInterface *)jarg1;
27770   {
27771     try {
27772       (arg1)->DestroyResource();
27773     } CALL_CATCH_EXCEPTION();
27774   }
27775
27776 }
27777
27778
27779 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_TargetTexture(void * jarg1) {
27780   unsigned int jresult ;
27781   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
27782   unsigned int result;
27783
27784   arg1 = (Dali::NativeImageInterface *)jarg1;
27785   {
27786     try {
27787       result = (unsigned int)(arg1)->TargetTexture();
27788     } CALL_CATCH_EXCEPTION(0);
27789   }
27790
27791   jresult = result;
27792   return jresult;
27793 }
27794
27795
27796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_PrepareTexture(void * jarg1) {
27797   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
27798
27799   arg1 = (Dali::NativeImageInterface *)jarg1;
27800   {
27801     try {
27802       (arg1)->PrepareTexture();
27803     } CALL_CATCH_EXCEPTION();
27804   }
27805
27806 }
27807
27808
27809 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetWidth(void * jarg1) {
27810   unsigned int jresult ;
27811   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
27812   unsigned int result;
27813
27814   arg1 = (Dali::NativeImageInterface *)jarg1;
27815   {
27816     try {
27817       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth();
27818     } CALL_CATCH_EXCEPTION(0);
27819   }
27820
27821   jresult = result;
27822   return jresult;
27823 }
27824
27825
27826 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetHeight(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)->GetHeight();
27835     } CALL_CATCH_EXCEPTION(0);
27836   }
27837
27838   jresult = result;
27839   return jresult;
27840 }
27841
27842
27843 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_RequiresBlending(void * jarg1) {
27844   unsigned int jresult ;
27845   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
27846   bool result;
27847
27848   arg1 = (Dali::NativeImageInterface *)jarg1;
27849   {
27850     try {
27851       result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending();
27852     } CALL_CATCH_EXCEPTION(0);
27853   }
27854
27855   jresult = result;
27856   return jresult;
27857 }
27858
27859 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TYPE_get() {
27860   int jresult ;
27861   int result;
27862
27863   result = (int)Dali::CameraActor::Property::TYPE;
27864   jresult = (int)result;
27865   return jresult;
27866 }
27867
27868
27869 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MODE_get() {
27870   int jresult ;
27871   int result;
27872
27873   result = (int)Dali::CameraActor::Property::PROJECTION_MODE;
27874   jresult = (int)result;
27875   return jresult;
27876 }
27877
27878
27879 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FIELD_OF_VIEW_get() {
27880   int jresult ;
27881   int result;
27882
27883   result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW;
27884   jresult = (int)result;
27885   return jresult;
27886 }
27887
27888
27889 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ASPECT_RATIO_get() {
27890   int jresult ;
27891   int result;
27892
27893   result = (int)Dali::CameraActor::Property::ASPECT_RATIO;
27894   jresult = (int)result;
27895   return jresult;
27896 }
27897
27898
27899 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_NEAR_PLANE_DISTANCE_get() {
27900   int jresult ;
27901   int result;
27902
27903   result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE;
27904   jresult = (int)result;
27905   return jresult;
27906 }
27907
27908
27909 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FAR_PLANE_DISTANCE_get() {
27910   int jresult ;
27911   int result;
27912
27913   result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE;
27914   jresult = (int)result;
27915   return jresult;
27916 }
27917
27918
27919 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_LEFT_PLANE_DISTANCE_get() {
27920   int jresult ;
27921   int result;
27922
27923   result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE;
27924   jresult = (int)result;
27925   return jresult;
27926 }
27927
27928
27929 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() {
27930   int jresult ;
27931   int result;
27932
27933   result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE;
27934   jresult = (int)result;
27935   return jresult;
27936 }
27937
27938
27939 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TOP_PLANE_DISTANCE_get() {
27940   int jresult ;
27941   int result;
27942
27943   result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE;
27944   jresult = (int)result;
27945   return jresult;
27946 }
27947
27948
27949 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() {
27950   int jresult ;
27951   int result;
27952
27953   result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE;
27954   jresult = (int)result;
27955   return jresult;
27956 }
27957
27958
27959 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TARGET_POSITION_get() {
27960   int jresult ;
27961   int result;
27962
27963   result = (int)Dali::CameraActor::Property::TARGET_POSITION;
27964   jresult = (int)result;
27965   return jresult;
27966 }
27967
27968
27969 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MATRIX_get() {
27970   int jresult ;
27971   int result;
27972
27973   result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX;
27974   jresult = (int)result;
27975   return jresult;
27976 }
27977
27978
27979 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_VIEW_MATRIX_get() {
27980   int jresult ;
27981   int result;
27982
27983   result = (int)Dali::CameraActor::Property::VIEW_MATRIX;
27984   jresult = (int)result;
27985   return jresult;
27986 }
27987
27988
27989 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_INVERT_Y_AXIS_get() {
27990   int jresult ;
27991   int result;
27992
27993   result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS;
27994   jresult = (int)result;
27995   return jresult;
27996 }
27997
27998
27999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor_Property() {
28000   void * jresult ;
28001   Dali::CameraActor::Property *result = 0 ;
28002
28003   {
28004     try {
28005       result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property();
28006     } CALL_CATCH_EXCEPTION(0);
28007   }
28008
28009   jresult = (void *)result;
28010   return jresult;
28011 }
28012
28013
28014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor_Property(void * jarg1) {
28015   Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ;
28016
28017   arg1 = (Dali::CameraActor::Property *)jarg1;
28018   {
28019     try {
28020       delete arg1;
28021     } CALL_CATCH_EXCEPTION();
28022   }
28023
28024 }
28025
28026
28027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_0() {
28028   void * jresult ;
28029   Dali::CameraActor *result = 0 ;
28030
28031   {
28032     try {
28033       result = (Dali::CameraActor *)new Dali::CameraActor();
28034     } CALL_CATCH_EXCEPTION(0);
28035   }
28036
28037   jresult = (void *)result;
28038   return jresult;
28039 }
28040
28041
28042 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_0() {
28043   void * jresult ;
28044   Dali::CameraActor result;
28045
28046   {
28047     try {
28048       result = Dali::CameraActor::New();
28049     } CALL_CATCH_EXCEPTION(0);
28050   }
28051
28052   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
28053   return jresult;
28054 }
28055
28056
28057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_1(void * jarg1) {
28058   void * jresult ;
28059   Dali::Size *arg1 = 0 ;
28060   Dali::CameraActor result;
28061
28062   arg1 = (Dali::Size *)jarg1;
28063   if (!arg1) {
28064     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
28065     return 0;
28066   }
28067   {
28068     try {
28069       result = Dali::CameraActor::New((Dali::Vector2 const &)*arg1);
28070     } CALL_CATCH_EXCEPTION(0);
28071   }
28072
28073   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
28074   return jresult;
28075 }
28076
28077
28078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_DownCast(void * jarg1) {
28079   void * jresult ;
28080   Dali::BaseHandle arg1 ;
28081   Dali::BaseHandle *argp1 ;
28082   Dali::CameraActor result;
28083
28084   argp1 = (Dali::BaseHandle *)jarg1;
28085   if (!argp1) {
28086     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
28087     return 0;
28088   }
28089   arg1 = *argp1;
28090   {
28091     try {
28092       result = Dali::CameraActor::DownCast(arg1);
28093     } CALL_CATCH_EXCEPTION(0);
28094   }
28095
28096   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
28097   return jresult;
28098 }
28099
28100
28101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor(void * jarg1) {
28102   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28103
28104   arg1 = (Dali::CameraActor *)jarg1;
28105   {
28106     try {
28107       delete arg1;
28108     } CALL_CATCH_EXCEPTION();
28109   }
28110
28111 }
28112
28113
28114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_1(void * jarg1) {
28115   void * jresult ;
28116   Dali::CameraActor *arg1 = 0 ;
28117   Dali::CameraActor *result = 0 ;
28118
28119   arg1 = (Dali::CameraActor *)jarg1;
28120   if (!arg1) {
28121     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
28122     return 0;
28123   }
28124   {
28125     try {
28126       result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1);
28127     } CALL_CATCH_EXCEPTION(0);
28128   }
28129
28130   jresult = (void *)result;
28131   return jresult;
28132 }
28133
28134
28135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_Assign(void * jarg1, void * jarg2) {
28136   void * jresult ;
28137   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28138   Dali::CameraActor *arg2 = 0 ;
28139   Dali::CameraActor *result = 0 ;
28140
28141   arg1 = (Dali::CameraActor *)jarg1;
28142   arg2 = (Dali::CameraActor *)jarg2;
28143   if (!arg2) {
28144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
28145     return 0;
28146   }
28147   {
28148     try {
28149       result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2);
28150     } CALL_CATCH_EXCEPTION(0);
28151   }
28152
28153   jresult = (void *)result;
28154   return jresult;
28155 }
28156
28157
28158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetType(void * jarg1, int jarg2) {
28159   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28160   Dali::Camera::Type arg2 ;
28161
28162   arg1 = (Dali::CameraActor *)jarg1;
28163   arg2 = (Dali::Camera::Type)jarg2;
28164   {
28165     try {
28166       (arg1)->SetType(arg2);
28167     } CALL_CATCH_EXCEPTION();
28168   }
28169
28170 }
28171
28172
28173 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetType(void * jarg1) {
28174   int jresult ;
28175   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28176   Dali::Camera::Type result;
28177
28178   arg1 = (Dali::CameraActor *)jarg1;
28179   {
28180     try {
28181       result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType();
28182     } CALL_CATCH_EXCEPTION(0);
28183   }
28184
28185   jresult = (int)result;
28186   return jresult;
28187 }
28188
28189
28190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetProjectionMode(void * jarg1, int jarg2) {
28191   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28192   Dali::Camera::ProjectionMode arg2 ;
28193
28194   arg1 = (Dali::CameraActor *)jarg1;
28195   arg2 = (Dali::Camera::ProjectionMode)jarg2;
28196   {
28197     try {
28198       (arg1)->SetProjectionMode(arg2);
28199     } CALL_CATCH_EXCEPTION();
28200   }
28201
28202 }
28203
28204
28205 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetProjectionMode(void * jarg1) {
28206   int jresult ;
28207   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28208   Dali::Camera::ProjectionMode result;
28209
28210   arg1 = (Dali::CameraActor *)jarg1;
28211   {
28212     try {
28213       result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode();
28214     } CALL_CATCH_EXCEPTION(0);
28215   }
28216
28217   jresult = (int)result;
28218   return jresult;
28219 }
28220
28221
28222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFieldOfView(void * jarg1, float jarg2) {
28223   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28224   float arg2 ;
28225
28226   arg1 = (Dali::CameraActor *)jarg1;
28227   arg2 = (float)jarg2;
28228   {
28229     try {
28230       (arg1)->SetFieldOfView(arg2);
28231     } CALL_CATCH_EXCEPTION();
28232   }
28233
28234 }
28235
28236
28237 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFieldOfView(void * jarg1) {
28238   float jresult ;
28239   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28240   float result;
28241
28242   arg1 = (Dali::CameraActor *)jarg1;
28243   {
28244     try {
28245       result = (float)(arg1)->GetFieldOfView();
28246     } CALL_CATCH_EXCEPTION(0);
28247   }
28248
28249   jresult = result;
28250   return jresult;
28251 }
28252
28253
28254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetAspectRatio(void * jarg1, float jarg2) {
28255   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28256   float arg2 ;
28257
28258   arg1 = (Dali::CameraActor *)jarg1;
28259   arg2 = (float)jarg2;
28260   {
28261     try {
28262       (arg1)->SetAspectRatio(arg2);
28263     } CALL_CATCH_EXCEPTION();
28264   }
28265
28266 }
28267
28268
28269 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetAspectRatio(void * jarg1) {
28270   float jresult ;
28271   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28272   float result;
28273
28274   arg1 = (Dali::CameraActor *)jarg1;
28275   {
28276     try {
28277       result = (float)(arg1)->GetAspectRatio();
28278     } CALL_CATCH_EXCEPTION(0);
28279   }
28280
28281   jresult = result;
28282   return jresult;
28283 }
28284
28285
28286 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) {
28287   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28288   float arg2 ;
28289
28290   arg1 = (Dali::CameraActor *)jarg1;
28291   arg2 = (float)jarg2;
28292   {
28293     try {
28294       (arg1)->SetNearClippingPlane(arg2);
28295     } CALL_CATCH_EXCEPTION();
28296   }
28297
28298 }
28299
28300
28301 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetNearClippingPlane(void * jarg1) {
28302   float jresult ;
28303   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28304   float result;
28305
28306   arg1 = (Dali::CameraActor *)jarg1;
28307   {
28308     try {
28309       result = (float)(arg1)->GetNearClippingPlane();
28310     } CALL_CATCH_EXCEPTION(0);
28311   }
28312
28313   jresult = result;
28314   return jresult;
28315 }
28316
28317
28318 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) {
28319   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28320   float arg2 ;
28321
28322   arg1 = (Dali::CameraActor *)jarg1;
28323   arg2 = (float)jarg2;
28324   {
28325     try {
28326       (arg1)->SetFarClippingPlane(arg2);
28327     } CALL_CATCH_EXCEPTION();
28328   }
28329
28330 }
28331
28332
28333 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFarClippingPlane(void * jarg1) {
28334   float jresult ;
28335   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28336   float result;
28337
28338   arg1 = (Dali::CameraActor *)jarg1;
28339   {
28340     try {
28341       result = (float)(arg1)->GetFarClippingPlane();
28342     } CALL_CATCH_EXCEPTION(0);
28343   }
28344
28345   jresult = result;
28346   return jresult;
28347 }
28348
28349
28350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) {
28351   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28352   Dali::Vector3 *arg2 = 0 ;
28353
28354   arg1 = (Dali::CameraActor *)jarg1;
28355   arg2 = (Dali::Vector3 *)jarg2;
28356   if (!arg2) {
28357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
28358     return ;
28359   }
28360   {
28361     try {
28362       (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2);
28363     } CALL_CATCH_EXCEPTION();
28364   }
28365
28366 }
28367
28368
28369 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_GetTargetPosition(void * jarg1) {
28370   void * jresult ;
28371   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28372   Dali::Vector3 result;
28373
28374   arg1 = (Dali::CameraActor *)jarg1;
28375   {
28376     try {
28377       result = ((Dali::CameraActor const *)arg1)->GetTargetPosition();
28378     } CALL_CATCH_EXCEPTION(0);
28379   }
28380
28381   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
28382   return jresult;
28383 }
28384
28385
28386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetInvertYAxis(void * jarg1, unsigned int jarg2) {
28387   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28388   bool arg2 ;
28389
28390   arg1 = (Dali::CameraActor *)jarg1;
28391   arg2 = jarg2 ? true : false;
28392   {
28393     try {
28394       (arg1)->SetInvertYAxis(arg2);
28395     } CALL_CATCH_EXCEPTION();
28396   }
28397
28398 }
28399
28400
28401 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CameraActor_GetInvertYAxis(void * jarg1) {
28402   unsigned int jresult ;
28403   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28404   bool result;
28405
28406   arg1 = (Dali::CameraActor *)jarg1;
28407   {
28408     try {
28409       result = (bool)(arg1)->GetInvertYAxis();
28410     } CALL_CATCH_EXCEPTION(0);
28411   }
28412
28413   jresult = result;
28414   return jresult;
28415 }
28416
28417
28418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) {
28419   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28420   Dali::Size *arg2 = 0 ;
28421
28422   arg1 = (Dali::CameraActor *)jarg1;
28423   arg2 = (Dali::Size *)jarg2;
28424   if (!arg2) {
28425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
28426     return ;
28427   }
28428   {
28429     try {
28430       (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2);
28431     } CALL_CATCH_EXCEPTION();
28432   }
28433
28434 }
28435
28436
28437 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) {
28438   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28439   Dali::Size *arg2 = 0 ;
28440
28441   arg1 = (Dali::CameraActor *)jarg1;
28442   arg2 = (Dali::Size *)jarg2;
28443   if (!arg2) {
28444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
28445     return ;
28446   }
28447   {
28448     try {
28449       (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2);
28450     } CALL_CATCH_EXCEPTION();
28451   }
28452
28453 }
28454
28455
28456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7) {
28457   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
28458   float arg2 ;
28459   float arg3 ;
28460   float arg4 ;
28461   float arg5 ;
28462   float arg6 ;
28463   float arg7 ;
28464
28465   arg1 = (Dali::CameraActor *)jarg1;
28466   arg2 = (float)jarg2;
28467   arg3 = (float)jarg3;
28468   arg4 = (float)jarg4;
28469   arg5 = (float)jarg5;
28470   arg6 = (float)jarg6;
28471   arg7 = (float)jarg7;
28472   {
28473     try {
28474       (arg1)->SetOrthographicProjection(arg2,arg3,arg4,arg5,arg6,arg7);
28475     } CALL_CATCH_EXCEPTION();
28476   }
28477
28478 }
28479
28480
28481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_0() {
28482   void * jresult ;
28483   std::pair< std::string,Dali::Property::Value > *result = 0 ;
28484
28485   {
28486     try {
28487       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >();
28488     } CALL_CATCH_EXCEPTION(0);
28489   }
28490
28491   jresult = (void *)result;
28492   return jresult;
28493 }
28494
28495
28496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) {
28497   void * jresult ;
28498   std::string arg1 ;
28499   Dali::Property::Value arg2 ;
28500   Dali::Property::Value *argp2 ;
28501   std::pair< std::string,Dali::Property::Value > *result = 0 ;
28502
28503   if (!jarg1) {
28504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
28505     return 0;
28506   }
28507   (&arg1)->assign(jarg1);
28508   argp2 = (Dali::Property::Value *)jarg2;
28509   if (!argp2) {
28510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
28511     return 0;
28512   }
28513   arg2 = *argp2;
28514   {
28515     try {
28516       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2);
28517     } CALL_CATCH_EXCEPTION(0);
28518   }
28519
28520   jresult = (void *)result;
28521   return jresult;
28522 }
28523
28524
28525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_2(void * jarg1) {
28526   void * jresult ;
28527   std::pair< std::string,Dali::Property::Value > *arg1 = 0 ;
28528   std::pair< std::string,Dali::Property::Value > *result = 0 ;
28529
28530   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
28531   if (!arg1) {
28532     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0);
28533     return 0;
28534   }
28535   {
28536     try {
28537       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);
28538     } CALL_CATCH_EXCEPTION(0);
28539   }
28540
28541   jresult = (void *)result;
28542   return jresult;
28543 }
28544
28545
28546 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_first_set(void * jarg1, char * jarg2) {
28547   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
28548   std::string *arg2 = 0 ;
28549
28550   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
28551   if (!jarg2) {
28552     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
28553     return ;
28554   }
28555   std::string arg2_str(jarg2);
28556   arg2 = &arg2_str;
28557   if (arg1) (arg1)->first = *arg2;
28558
28559   //argout typemap for const std::string&
28560
28561 }
28562
28563
28564 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StringValuePair_first_get(void * jarg1) {
28565   char * jresult ;
28566   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
28567   std::string *result = 0 ;
28568
28569   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
28570   result = (std::string *) & ((arg1)->first);
28571   jresult = SWIG_csharp_string_callback(result->c_str());
28572   return jresult;
28573 }
28574
28575
28576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_second_set(void * jarg1, void * jarg2) {
28577   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
28578   Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ;
28579
28580   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
28581   arg2 = (Dali::Property::Value *)jarg2;
28582   if (arg1) (arg1)->second = *arg2;
28583 }
28584
28585
28586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StringValuePair_second_get(void * jarg1) {
28587   void * jresult ;
28588   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
28589   Dali::Property::Value *result = 0 ;
28590
28591   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
28592   result = (Dali::Property::Value *)& ((arg1)->second);
28593   jresult = (void *)result;
28594   return jresult;
28595 }
28596
28597
28598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StringValuePair(void * jarg1) {
28599   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
28600
28601   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
28602   {
28603     try {
28604       delete arg1;
28605     } CALL_CATCH_EXCEPTION();
28606   }
28607
28608 }
28609
28610
28611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Clear(void * jarg1) {
28612   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28613
28614   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28615   {
28616     try {
28617       (arg1)->clear();
28618     } CALL_CATCH_EXCEPTION();
28619   }
28620
28621 }
28622
28623
28624 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Add(void * jarg1, void * jarg2) {
28625   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28626   Dali::TouchPoint *arg2 = 0 ;
28627
28628   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28629   arg2 = (Dali::TouchPoint *)jarg2;
28630   if (!arg2) {
28631     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
28632     return ;
28633   }
28634   {
28635     try {
28636       (arg1)->push_back((Dali::TouchPoint const &)*arg2);
28637     } CALL_CATCH_EXCEPTION();
28638   }
28639
28640 }
28641
28642
28643 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_size(void * jarg1) {
28644   unsigned long jresult ;
28645   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28646   std::vector< Dali::TouchPoint >::size_type result;
28647
28648   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28649   {
28650     try {
28651       result = ((std::vector< Dali::TouchPoint > const *)arg1)->size();
28652     } CALL_CATCH_EXCEPTION(0);
28653   }
28654
28655   jresult = (unsigned long)result;
28656   return jresult;
28657 }
28658
28659
28660 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_capacity(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)->capacity();
28669     } CALL_CATCH_EXCEPTION(0);
28670   }
28671
28672   jresult = (unsigned long)result;
28673   return jresult;
28674 }
28675
28676
28677 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) {
28678   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28679   std::vector< Dali::TouchPoint >::size_type arg2 ;
28680
28681   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28682   arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2;
28683   {
28684     try {
28685       (arg1)->reserve(arg2);
28686     } CALL_CATCH_EXCEPTION();
28687   }
28688
28689 }
28690
28691
28692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_0() {
28693   void * jresult ;
28694   std::vector< Dali::TouchPoint > *result = 0 ;
28695
28696   {
28697     try {
28698       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >();
28699     } CALL_CATCH_EXCEPTION(0);
28700   }
28701
28702   jresult = (void *)result;
28703   return jresult;
28704 }
28705
28706
28707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_1(void * jarg1) {
28708   void * jresult ;
28709   std::vector< Dali::TouchPoint > *arg1 = 0 ;
28710   std::vector< Dali::TouchPoint > *result = 0 ;
28711
28712   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28713   if (!arg1) {
28714     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
28715     return 0;
28716   }
28717   {
28718     try {
28719       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1);
28720     } CALL_CATCH_EXCEPTION(0);
28721   }
28722
28723   jresult = (void *)result;
28724   return jresult;
28725 }
28726
28727
28728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_2(int jarg1) {
28729   void * jresult ;
28730   int arg1 ;
28731   std::vector< Dali::TouchPoint > *result = 0 ;
28732
28733   arg1 = (int)jarg1;
28734   {
28735     try {
28736       try {
28737         result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1);
28738       }
28739       catch(std::out_of_range &_e) {
28740         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
28741         return 0;
28742       }
28743
28744     } CALL_CATCH_EXCEPTION(0);
28745   }
28746
28747   jresult = (void *)result;
28748   return jresult;
28749 }
28750
28751
28752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) {
28753   void * jresult ;
28754   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28755   int arg2 ;
28756   SwigValueWrapper< Dali::TouchPoint > result;
28757
28758   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28759   arg2 = (int)jarg2;
28760   {
28761     try {
28762       try {
28763         result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2);
28764       }
28765       catch(std::out_of_range &_e) {
28766         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
28767         return 0;
28768       }
28769
28770     } CALL_CATCH_EXCEPTION(0);
28771   }
28772
28773   jresult = new Dali::TouchPoint((const Dali::TouchPoint &)result);
28774   return jresult;
28775 }
28776
28777
28778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitem(void * jarg1, int jarg2) {
28779   void * jresult ;
28780   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28781   int arg2 ;
28782   Dali::TouchPoint *result = 0 ;
28783
28784   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28785   arg2 = (int)jarg2;
28786   {
28787     try {
28788       try {
28789         result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2);
28790       }
28791       catch(std::out_of_range &_e) {
28792         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
28793         return 0;
28794       }
28795
28796     } CALL_CATCH_EXCEPTION(0);
28797   }
28798
28799   jresult = (void *)result;
28800   return jresult;
28801 }
28802
28803
28804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
28805   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28806   int arg2 ;
28807   Dali::TouchPoint *arg3 = 0 ;
28808
28809   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28810   arg2 = (int)jarg2;
28811   arg3 = (Dali::TouchPoint *)jarg3;
28812   if (!arg3) {
28813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
28814     return ;
28815   }
28816   {
28817     try {
28818       try {
28819         std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3);
28820       }
28821       catch(std::out_of_range &_e) {
28822         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
28823         return ;
28824       }
28825
28826     } CALL_CATCH_EXCEPTION();
28827   }
28828
28829 }
28830
28831
28832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_AddRange(void * jarg1, void * jarg2) {
28833   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28834   std::vector< Dali::TouchPoint > *arg2 = 0 ;
28835
28836   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28837   arg2 = (std::vector< Dali::TouchPoint > *)jarg2;
28838   if (!arg2) {
28839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
28840     return ;
28841   }
28842   {
28843     try {
28844       std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2);
28845     } CALL_CATCH_EXCEPTION();
28846   }
28847
28848 }
28849
28850
28851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
28852   void * jresult ;
28853   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28854   int arg2 ;
28855   int arg3 ;
28856   std::vector< Dali::TouchPoint > *result = 0 ;
28857
28858   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28859   arg2 = (int)jarg2;
28860   arg3 = (int)jarg3;
28861   {
28862     try {
28863       try {
28864         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3);
28865       }
28866       catch(std::out_of_range &_e) {
28867         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
28868         return 0;
28869       }
28870       catch(std::invalid_argument &_e) {
28871         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
28872         return 0;
28873       }
28874
28875     } CALL_CATCH_EXCEPTION(0);
28876   }
28877
28878   jresult = (void *)result;
28879   return jresult;
28880 }
28881
28882
28883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
28884   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28885   int arg2 ;
28886   Dali::TouchPoint *arg3 = 0 ;
28887
28888   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28889   arg2 = (int)jarg2;
28890   arg3 = (Dali::TouchPoint *)jarg3;
28891   if (!arg3) {
28892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
28893     return ;
28894   }
28895   {
28896     try {
28897       try {
28898         std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3);
28899       }
28900       catch(std::out_of_range &_e) {
28901         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
28902         return ;
28903       }
28904
28905     } CALL_CATCH_EXCEPTION();
28906   }
28907
28908 }
28909
28910
28911 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
28912   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28913   int arg2 ;
28914   std::vector< Dali::TouchPoint > *arg3 = 0 ;
28915
28916   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28917   arg2 = (int)jarg2;
28918   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
28919   if (!arg3) {
28920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
28921     return ;
28922   }
28923   {
28924     try {
28925       try {
28926         std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
28927       }
28928       catch(std::out_of_range &_e) {
28929         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
28930         return ;
28931       }
28932
28933     } CALL_CATCH_EXCEPTION();
28934   }
28935
28936 }
28937
28938
28939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveAt(void * jarg1, int jarg2) {
28940   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28941   int arg2 ;
28942
28943   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28944   arg2 = (int)jarg2;
28945   {
28946     try {
28947       try {
28948         std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2);
28949       }
28950       catch(std::out_of_range &_e) {
28951         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
28952         return ;
28953       }
28954
28955     } CALL_CATCH_EXCEPTION();
28956   }
28957
28958 }
28959
28960
28961 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
28962   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
28963   int arg2 ;
28964   int arg3 ;
28965
28966   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
28967   arg2 = (int)jarg2;
28968   arg3 = (int)jarg3;
28969   {
28970     try {
28971       try {
28972         std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3);
28973       }
28974       catch(std::out_of_range &_e) {
28975         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
28976         return ;
28977       }
28978       catch(std::invalid_argument &_e) {
28979         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
28980         return ;
28981       }
28982
28983     } CALL_CATCH_EXCEPTION();
28984   }
28985
28986 }
28987
28988
28989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_Repeat(void * jarg1, int jarg2) {
28990   void * jresult ;
28991   Dali::TouchPoint *arg1 = 0 ;
28992   int arg2 ;
28993   std::vector< Dali::TouchPoint > *result = 0 ;
28994
28995   arg1 = (Dali::TouchPoint *)jarg1;
28996   if (!arg1) {
28997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
28998     return 0;
28999   }
29000   arg2 = (int)jarg2;
29001   {
29002     try {
29003       try {
29004         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2);
29005       }
29006       catch(std::out_of_range &_e) {
29007         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
29008         return 0;
29009       }
29010
29011     } CALL_CATCH_EXCEPTION(0);
29012   }
29013
29014   jresult = (void *)result;
29015   return jresult;
29016 }
29017
29018
29019 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_0(void * jarg1) {
29020   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
29021
29022   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
29023   {
29024     try {
29025       std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1);
29026     } CALL_CATCH_EXCEPTION();
29027   }
29028
29029 }
29030
29031
29032 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
29033   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
29034   int arg2 ;
29035   int arg3 ;
29036
29037   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
29038   arg2 = (int)jarg2;
29039   arg3 = (int)jarg3;
29040   {
29041     try {
29042       try {
29043         std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
29044       }
29045       catch(std::out_of_range &_e) {
29046         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
29047         return ;
29048       }
29049       catch(std::invalid_argument &_e) {
29050         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
29051         return ;
29052       }
29053
29054     } CALL_CATCH_EXCEPTION();
29055   }
29056
29057 }
29058
29059
29060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
29061   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
29062   int arg2 ;
29063   std::vector< Dali::TouchPoint > *arg3 = 0 ;
29064
29065   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
29066   arg2 = (int)jarg2;
29067   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
29068   if (!arg3) {
29069     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
29070     return ;
29071   }
29072   {
29073     try {
29074       try {
29075         std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
29076       }
29077       catch(std::out_of_range &_e) {
29078         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
29079         return ;
29080       }
29081
29082     } CALL_CATCH_EXCEPTION();
29083   }
29084
29085 }
29086
29087
29088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPointContainer(void * jarg1) {
29089   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
29090
29091   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
29092   {
29093     try {
29094       delete arg1;
29095     } CALL_CATCH_EXCEPTION();
29096   }
29097
29098 }
29099
29100
29101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_0() {
29102   void * jresult ;
29103   Dali::Rect< int > *result = 0 ;
29104
29105   {
29106     try {
29107       result = (Dali::Rect< int > *)new Dali::Rect< int >();
29108     } CALL_CATCH_EXCEPTION(0);
29109   }
29110
29111   jresult = (void *)result;
29112   return jresult;
29113 }
29114
29115
29116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) {
29117   void * jresult ;
29118   int arg1 ;
29119   int arg2 ;
29120   int arg3 ;
29121   int arg4 ;
29122   Dali::Rect< int > *result = 0 ;
29123
29124   arg1 = (int)jarg1;
29125   arg2 = (int)jarg2;
29126   arg3 = (int)jarg3;
29127   arg4 = (int)jarg4;
29128   {
29129     try {
29130       result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4);
29131     } CALL_CATCH_EXCEPTION(0);
29132   }
29133
29134   jresult = (void *)result;
29135   return jresult;
29136 }
29137
29138
29139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_2(void * jarg1) {
29140   void * jresult ;
29141   Dali::Rect< int > *arg1 = 0 ;
29142   Dali::Rect< int > *result = 0 ;
29143
29144   arg1 = (Dali::Rect< int > *)jarg1;
29145   if (!arg1) {
29146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
29147     return 0;
29148   }
29149   {
29150     try {
29151       result = (Dali::Rect< int > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1);
29152     } CALL_CATCH_EXCEPTION(0);
29153   }
29154
29155   jresult = (void *)result;
29156   return jresult;
29157 }
29158
29159
29160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rectangle_Assign(void * jarg1, void * jarg2) {
29161   void * jresult ;
29162   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29163   Dali::Rect< int > *arg2 = 0 ;
29164   Dali::Rect< int > *result = 0 ;
29165
29166   arg1 = (Dali::Rect< int > *)jarg1;
29167   arg2 = (Dali::Rect< int > *)jarg2;
29168   if (!arg2) {
29169     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
29170     return 0;
29171   }
29172   {
29173     try {
29174       result = (Dali::Rect< int > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2);
29175     } CALL_CATCH_EXCEPTION(0);
29176   }
29177
29178   jresult = (void *)result;
29179   return jresult;
29180 }
29181
29182
29183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
29184   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29185   int arg2 ;
29186   int arg3 ;
29187   int arg4 ;
29188   int arg5 ;
29189
29190   arg1 = (Dali::Rect< int > *)jarg1;
29191   arg2 = (int)jarg2;
29192   arg3 = (int)jarg3;
29193   arg4 = (int)jarg4;
29194   arg5 = (int)jarg5;
29195   {
29196     try {
29197       (arg1)->Set(arg2,arg3,arg4,arg5);
29198     } CALL_CATCH_EXCEPTION();
29199   }
29200
29201 }
29202
29203
29204 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_IsEmpty(void * jarg1) {
29205   unsigned int jresult ;
29206   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29207   bool result;
29208
29209   arg1 = (Dali::Rect< int > *)jarg1;
29210   {
29211     try {
29212       result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty();
29213     } CALL_CATCH_EXCEPTION(0);
29214   }
29215
29216   jresult = result;
29217   return jresult;
29218 }
29219
29220
29221 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Left(void * jarg1) {
29222   int jresult ;
29223   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29224   int result;
29225
29226   arg1 = (Dali::Rect< int > *)jarg1;
29227   {
29228     try {
29229       result = (int)((Dali::Rect< int > const *)arg1)->Left();
29230     } CALL_CATCH_EXCEPTION(0);
29231   }
29232
29233   jresult = result;
29234   return jresult;
29235 }
29236
29237
29238 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Right(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)->Right();
29247     } CALL_CATCH_EXCEPTION(0);
29248   }
29249
29250   jresult = result;
29251   return jresult;
29252 }
29253
29254
29255 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Top(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)->Top();
29264     } CALL_CATCH_EXCEPTION(0);
29265   }
29266
29267   jresult = result;
29268   return jresult;
29269 }
29270
29271
29272 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Bottom(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)->Bottom();
29281     } CALL_CATCH_EXCEPTION(0);
29282   }
29283
29284   jresult = result;
29285   return jresult;
29286 }
29287
29288
29289 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Area(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)->Area();
29298     } CALL_CATCH_EXCEPTION(0);
29299   }
29300
29301   jresult = result;
29302   return jresult;
29303 }
29304
29305
29306 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Intersects(void * jarg1, void * jarg2) {
29307   unsigned int jresult ;
29308   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29309   Dali::Rect< int > *arg2 = 0 ;
29310   bool result;
29311
29312   arg1 = (Dali::Rect< int > *)jarg1;
29313   arg2 = (Dali::Rect< int > *)jarg2;
29314   if (!arg2) {
29315     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
29316     return 0;
29317   }
29318   {
29319     try {
29320       result = (bool)((Dali::Rect< int > const *)arg1)->Intersects((Dali::Rect< int > const &)*arg2);
29321     } CALL_CATCH_EXCEPTION(0);
29322   }
29323
29324   jresult = result;
29325   return jresult;
29326 }
29327
29328
29329 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Contains(void * jarg1, void * jarg2) {
29330   unsigned int jresult ;
29331   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29332   Dali::Rect< int > *arg2 = 0 ;
29333   bool result;
29334
29335   arg1 = (Dali::Rect< int > *)jarg1;
29336   arg2 = (Dali::Rect< int > *)jarg2;
29337   if (!arg2) {
29338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
29339     return 0;
29340   }
29341   {
29342     try {
29343       result = (bool)((Dali::Rect< int > const *)arg1)->Contains((Dali::Rect< int > const &)*arg2);
29344     } CALL_CATCH_EXCEPTION(0);
29345   }
29346
29347   jresult = result;
29348   return jresult;
29349 }
29350
29351
29352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_x_set(void * jarg1, int jarg2) {
29353   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29354   int arg2 ;
29355
29356   arg1 = (Dali::Rect< int > *)jarg1;
29357   arg2 = (int)jarg2;
29358   if (arg1) (arg1)->x = arg2;
29359 }
29360
29361
29362 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_x_get(void * jarg1) {
29363   int jresult ;
29364   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29365   int result;
29366
29367   arg1 = (Dali::Rect< int > *)jarg1;
29368   result = (int) ((arg1)->x);
29369   jresult = result;
29370   return jresult;
29371 }
29372
29373
29374 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_left_set(void * jarg1, int jarg2) {
29375   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29376   int arg2 ;
29377
29378   arg1 = (Dali::Rect< int > *)jarg1;
29379   arg2 = (int)jarg2;
29380   if (arg1) (arg1)->left = arg2;
29381 }
29382
29383
29384 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_left_get(void * jarg1) {
29385   int jresult ;
29386   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29387   int result;
29388
29389   arg1 = (Dali::Rect< int > *)jarg1;
29390   result = (int) ((arg1)->left);
29391   jresult = result;
29392   return jresult;
29393 }
29394
29395
29396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_y_set(void * jarg1, int jarg2) {
29397   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29398   int arg2 ;
29399
29400   arg1 = (Dali::Rect< int > *)jarg1;
29401   arg2 = (int)jarg2;
29402   if (arg1) (arg1)->y = arg2;
29403 }
29404
29405
29406 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_y_get(void * jarg1) {
29407   int jresult ;
29408   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29409   int result;
29410
29411   arg1 = (Dali::Rect< int > *)jarg1;
29412   result = (int) ((arg1)->y);
29413   jresult = result;
29414   return jresult;
29415 }
29416
29417
29418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_right_set(void * jarg1, int jarg2) {
29419   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29420   int arg2 ;
29421
29422   arg1 = (Dali::Rect< int > *)jarg1;
29423   arg2 = (int)jarg2;
29424   if (arg1) (arg1)->right = arg2;
29425 }
29426
29427
29428 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_right_get(void * jarg1) {
29429   int jresult ;
29430   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29431   int result;
29432
29433   arg1 = (Dali::Rect< int > *)jarg1;
29434   result = (int) ((arg1)->right);
29435   jresult = result;
29436   return jresult;
29437 }
29438
29439
29440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_width_set(void * jarg1, int jarg2) {
29441   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29442   int arg2 ;
29443
29444   arg1 = (Dali::Rect< int > *)jarg1;
29445   arg2 = (int)jarg2;
29446   if (arg1) (arg1)->width = arg2;
29447 }
29448
29449
29450 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_width_get(void * jarg1) {
29451   int jresult ;
29452   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29453   int result;
29454
29455   arg1 = (Dali::Rect< int > *)jarg1;
29456   result = (int) ((arg1)->width);
29457   jresult = result;
29458   return jresult;
29459 }
29460
29461
29462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_bottom_set(void * jarg1, int jarg2) {
29463   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29464   int arg2 ;
29465
29466   arg1 = (Dali::Rect< int > *)jarg1;
29467   arg2 = (int)jarg2;
29468   if (arg1) (arg1)->bottom = arg2;
29469 }
29470
29471
29472 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_bottom_get(void * jarg1) {
29473   int jresult ;
29474   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29475   int result;
29476
29477   arg1 = (Dali::Rect< int > *)jarg1;
29478   result = (int) ((arg1)->bottom);
29479   jresult = result;
29480   return jresult;
29481 }
29482
29483
29484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_height_set(void * jarg1, int jarg2) {
29485   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29486   int arg2 ;
29487
29488   arg1 = (Dali::Rect< int > *)jarg1;
29489   arg2 = (int)jarg2;
29490   if (arg1) (arg1)->height = arg2;
29491 }
29492
29493
29494 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_height_get(void * jarg1) {
29495   int jresult ;
29496   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29497   int result;
29498
29499   arg1 = (Dali::Rect< int > *)jarg1;
29500   result = (int) ((arg1)->height);
29501   jresult = result;
29502   return jresult;
29503 }
29504
29505
29506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_top_set(void * jarg1, int jarg2) {
29507   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29508   int arg2 ;
29509
29510   arg1 = (Dali::Rect< int > *)jarg1;
29511   arg2 = (int)jarg2;
29512   if (arg1) (arg1)->top = arg2;
29513 }
29514
29515
29516 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_top_get(void * jarg1) {
29517   int jresult ;
29518   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29519   int result;
29520
29521   arg1 = (Dali::Rect< int > *)jarg1;
29522   result = (int) ((arg1)->top);
29523   jresult = result;
29524   return jresult;
29525 }
29526
29527
29528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rectangle(void * jarg1) {
29529   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
29530
29531   arg1 = (Dali::Rect< int > *)jarg1;
29532   {
29533     try {
29534       delete arg1;
29535     } CALL_CATCH_EXCEPTION();
29536   }
29537
29538 }
29539
29540
29541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_0() {
29542   void * jresult ;
29543   Dali::Rect< float > *result = 0 ;
29544
29545   {
29546     try {
29547       result = (Dali::Rect< float > *)new Dali::Rect< float >();
29548     } CALL_CATCH_EXCEPTION(0);
29549   }
29550
29551   jresult = (void *)result;
29552   return jresult;
29553 }
29554
29555
29556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
29557   void * jresult ;
29558   float arg1 ;
29559   float arg2 ;
29560   float arg3 ;
29561   float arg4 ;
29562   Dali::Rect< float > *result = 0 ;
29563
29564   arg1 = (float)jarg1;
29565   arg2 = (float)jarg2;
29566   arg3 = (float)jarg4;
29567   arg4 = (float)jarg3;
29568   {
29569     try {
29570       result = (Dali::Rect< float > *)new Dali::Rect< float >(arg1,arg2,arg3,arg4);
29571     } CALL_CATCH_EXCEPTION(0);
29572   }
29573
29574   jresult = (void *)result;
29575   return jresult;
29576 }
29577
29578
29579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_2(void * jarg1) {
29580   void * jresult ;
29581   Dali::Rect< float > *arg1 = 0 ;
29582   Dali::Rect< float > *result = 0 ;
29583
29584   arg1 = (Dali::Rect< float > *)jarg1;
29585   if (!arg1) {
29586     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
29587     return 0;
29588   }
29589   {
29590     try {
29591       result = (Dali::Rect< float > *)new Dali::Rect< float >((Dali::Rect< float > const &)*arg1);
29592     } CALL_CATCH_EXCEPTION(0);
29593   }
29594
29595   jresult = (void *)result;
29596   return jresult;
29597 }
29598
29599
29600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PaddingType_Assign(void * jarg1, void * jarg2) {
29601   void * jresult ;
29602   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
29603   Dali::Rect< float > *arg2 = 0 ;
29604   Dali::Rect< float > *result = 0 ;
29605
29606   arg1 = (Dali::Rect< float > *)jarg1;
29607   arg2 = (Dali::Rect< float > *)jarg2;
29608   if (!arg2) {
29609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
29610     return 0;
29611   }
29612   {
29613     try {
29614       result = (Dali::Rect< float > *) &(arg1)->operator =((Dali::Rect< float > const &)*arg2);
29615     } CALL_CATCH_EXCEPTION(0);
29616   }
29617
29618   jresult = (void *)result;
29619   return jresult;
29620 }
29621
29622
29623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_Set(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
29624   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
29625   float arg2 ;
29626   float arg3 ;
29627   float arg4 ;
29628   float arg5 ;
29629
29630   arg1 = (Dali::Rect< float > *)jarg1;
29631   arg2 = (float)jarg2;
29632   arg3 = (float)jarg3;
29633   arg4 = (float)jarg5;
29634   arg5 = (float)jarg4;
29635   {
29636     try {
29637       (arg1)->Set(arg2,arg3,arg4,arg5);
29638     } CALL_CATCH_EXCEPTION();
29639   }
29640
29641 }
29642
29643
29644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_left_set(void * jarg1, float jarg2) {
29645   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
29646   float arg2 ;
29647
29648   arg1 = (Dali::Rect< float > *)jarg1;
29649   arg2 = (float)jarg2;
29650   if (arg1) (arg1)->left = arg2;
29651 }
29652
29653
29654 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_left_get(void * jarg1) {
29655   float jresult ;
29656   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
29657   float result;
29658
29659   arg1 = (Dali::Rect< float > *)jarg1;
29660   result = (float) ((arg1)->left);
29661   jresult = result;
29662   return jresult;
29663 }
29664
29665
29666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_start_set(void * jarg1, float jarg2) {
29667   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
29668   float arg2 ;
29669
29670   arg1 = (Dali::Rect< float > *)jarg1;
29671   arg2 = (float)jarg2;
29672   if (arg1) (arg1)->left = arg2;
29673 }
29674
29675
29676 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_start_get(void * jarg1) {
29677   float jresult ;
29678   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
29679   float result;
29680
29681   arg1 = (Dali::Rect< float > *)jarg1;
29682   result = (float) ((arg1)->left);
29683   jresult = result;
29684   return jresult;
29685 }
29686
29687
29688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_right_set(void * jarg1, float jarg2) {
29689   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
29690   float arg2 ;
29691
29692   arg1 = (Dali::Rect< float > *)jarg1;
29693   arg2 = (float)jarg2;
29694   if (arg1) (arg1)->right = arg2;
29695 }
29696
29697
29698 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_right_get(void * jarg1) {
29699   float jresult ;
29700   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
29701   float result;
29702
29703   arg1 = (Dali::Rect< float > *)jarg1;
29704   result = (float) ((arg1)->right);
29705   jresult = result;
29706   return jresult;
29707 }
29708
29709
29710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_end_set(void * jarg1, float jarg2) {
29711   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
29712   float arg2 ;
29713
29714   arg1 = (Dali::Rect< float > *)jarg1;
29715   arg2 = (float)jarg2;
29716   if (arg1) (arg1)->right = arg2;
29717 }
29718
29719
29720 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_end_get(void * jarg1) {
29721   float jresult ;
29722   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
29723   float result;
29724
29725   arg1 = (Dali::Rect< float > *)jarg1;
29726   result = (float) ((arg1)->right);
29727   jresult = result;
29728   return jresult;
29729 }
29730
29731
29732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_bottom_set(void * jarg1, float jarg2) {
29733   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
29734   float arg2 ;
29735
29736   arg1 = (Dali::Rect< float > *)jarg1;
29737   arg2 = (float)jarg2;
29738   if (arg1) (arg1)->bottom = arg2;
29739 }
29740
29741
29742 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_bottom_get(void * jarg1) {
29743   float jresult ;
29744   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
29745   float result;
29746
29747   arg1 = (Dali::Rect< float > *)jarg1;
29748   result = (float) ((arg1)->bottom);
29749   jresult = result;
29750   return jresult;
29751 }
29752
29753
29754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_top_set(void * jarg1, float jarg2) {
29755   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
29756   float arg2 ;
29757
29758   arg1 = (Dali::Rect< float > *)jarg1;
29759   arg2 = (float)jarg2;
29760   if (arg1) (arg1)->top = arg2;
29761 }
29762
29763
29764 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_top_get(void * jarg1) {
29765   float jresult ;
29766   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
29767   float result;
29768
29769   arg1 = (Dali::Rect< float > *)jarg1;
29770   result = (float) ((arg1)->top);
29771   jresult = result;
29772   return jresult;
29773 }
29774
29775
29776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PaddingType(void * jarg1) {
29777   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
29778
29779   arg1 = (Dali::Rect< float > *)jarg1;
29780   {
29781     try {
29782       delete arg1;
29783     } CALL_CATCH_EXCEPTION();
29784   }
29785
29786 }
29787
29788
29789 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorInteger_BaseType_get() {
29790   int jresult ;
29791   int result;
29792
29793   result = (int)Dali::Vector< int >::BaseType;
29794   jresult = (int)result;
29795   return jresult;
29796 }
29797
29798
29799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_0() {
29800   void * jresult ;
29801   Dali::Vector< int > *result = 0 ;
29802
29803   {
29804     try {
29805       result = (Dali::Vector< int > *)new Dali::Vector< int >();
29806     } CALL_CATCH_EXCEPTION(0);
29807   }
29808
29809   jresult = (void *)result;
29810   return jresult;
29811 }
29812
29813
29814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorInteger(void * jarg1) {
29815   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
29816
29817   arg1 = (Dali::Vector< int > *)jarg1;
29818   {
29819     try {
29820       delete arg1;
29821     } CALL_CATCH_EXCEPTION();
29822   }
29823
29824 }
29825
29826
29827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_1(void * jarg1) {
29828   void * jresult ;
29829   Dali::Vector< int > *arg1 = 0 ;
29830   Dali::Vector< int > *result = 0 ;
29831
29832   arg1 = (Dali::Vector< int > *)jarg1;
29833   if (!arg1) {
29834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
29835     return 0;
29836   }
29837   {
29838     try {
29839       result = (Dali::Vector< int > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1);
29840     } CALL_CATCH_EXCEPTION(0);
29841   }
29842
29843   jresult = (void *)result;
29844   return jresult;
29845 }
29846
29847
29848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Assign(void * jarg1, void * jarg2) {
29849   void * jresult ;
29850   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
29851   Dali::Vector< int > *arg2 = 0 ;
29852   Dali::Vector< int > *result = 0 ;
29853
29854   arg1 = (Dali::Vector< int > *)jarg1;
29855   arg2 = (Dali::Vector< int > *)jarg2;
29856   if (!arg2) {
29857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
29858     return 0;
29859   }
29860   {
29861     try {
29862       result = (Dali::Vector< int > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2);
29863     } CALL_CATCH_EXCEPTION(0);
29864   }
29865
29866   jresult = (void *)result;
29867   return jresult;
29868 }
29869
29870
29871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Begin(void * jarg1) {
29872   void * jresult ;
29873   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
29874   Dali::Vector< int >::Iterator result;
29875
29876   arg1 = (Dali::Vector< int > *)jarg1;
29877   {
29878     try {
29879       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin();
29880     } CALL_CATCH_EXCEPTION(0);
29881   }
29882
29883   jresult = (void *)result;
29884   return jresult;
29885 }
29886
29887
29888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_End(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)->End();
29897     } CALL_CATCH_EXCEPTION(0);
29898   }
29899
29900   jresult = (void *)result;
29901   return jresult;
29902 }
29903
29904
29905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
29906   void * jresult ;
29907   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
29908   Dali::Vector< int >::SizeType arg2 ;
29909   Dali::Vector< int >::ItemType *result = 0 ;
29910
29911   arg1 = (Dali::Vector< int > *)jarg1;
29912   arg2 = (Dali::Vector< int >::SizeType)jarg2;
29913   {
29914     try {
29915       result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2);
29916     } CALL_CATCH_EXCEPTION(0);
29917   }
29918
29919   jresult = (void *)result;
29920   return jresult;
29921 }
29922
29923
29924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_PushBack(void * jarg1, int jarg2) {
29925   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
29926   Dali::Vector< int >::ItemType *arg2 = 0 ;
29927   Dali::Vector< int >::ItemType temp2 ;
29928
29929   arg1 = (Dali::Vector< int > *)jarg1;
29930   temp2 = (Dali::Vector< int >::ItemType)jarg2;
29931   arg2 = &temp2;
29932   {
29933     try {
29934       (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2);
29935     } CALL_CATCH_EXCEPTION();
29936   }
29937
29938 }
29939
29940
29941 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
29942   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
29943   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
29944   Dali::Vector< int >::ItemType *arg3 = 0 ;
29945   Dali::Vector< int >::ItemType temp3 ;
29946
29947   arg1 = (Dali::Vector< int > *)jarg1;
29948   arg2 = (Dali::Vector< int >::Iterator)jarg2;
29949   temp3 = (Dali::Vector< int >::ItemType)jarg3;
29950   arg3 = &temp3;
29951   {
29952     try {
29953       (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
29954     } CALL_CATCH_EXCEPTION();
29955   }
29956
29957 }
29958
29959
29960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
29961   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
29962   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
29963   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
29964   Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ;
29965
29966   arg1 = (Dali::Vector< int > *)jarg1;
29967   arg2 = (Dali::Vector< int >::Iterator)jarg2;
29968   arg3 = (Dali::Vector< int >::Iterator)jarg3;
29969   arg4 = (Dali::Vector< int >::Iterator)jarg4;
29970   {
29971     try {
29972       (arg1)->Insert(arg2,arg3,arg4);
29973     } CALL_CATCH_EXCEPTION();
29974   }
29975
29976 }
29977
29978
29979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) {
29980   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
29981   Dali::Vector< int >::SizeType arg2 ;
29982
29983   arg1 = (Dali::Vector< int > *)jarg1;
29984   arg2 = (Dali::Vector< int >::SizeType)jarg2;
29985   {
29986     try {
29987       (arg1)->Reserve(arg2);
29988     } CALL_CATCH_EXCEPTION();
29989   }
29990
29991 }
29992
29993
29994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
29995   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
29996   Dali::Vector< int >::SizeType arg2 ;
29997
29998   arg1 = (Dali::Vector< int > *)jarg1;
29999   arg2 = (Dali::Vector< int >::SizeType)jarg2;
30000   {
30001     try {
30002       (arg1)->Resize(arg2);
30003     } CALL_CATCH_EXCEPTION();
30004   }
30005
30006 }
30007
30008
30009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) {
30010   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
30011   Dali::Vector< int >::SizeType arg2 ;
30012   Dali::Vector< int >::ItemType *arg3 = 0 ;
30013   Dali::Vector< int >::ItemType temp3 ;
30014
30015   arg1 = (Dali::Vector< int > *)jarg1;
30016   arg2 = (Dali::Vector< int >::SizeType)jarg2;
30017   temp3 = (Dali::Vector< int >::ItemType)jarg3;
30018   arg3 = &temp3;
30019   {
30020     try {
30021       (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
30022     } CALL_CATCH_EXCEPTION();
30023   }
30024
30025 }
30026
30027
30028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) {
30029   void * jresult ;
30030   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
30031   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
30032   Dali::Vector< int >::Iterator result;
30033
30034   arg1 = (Dali::Vector< int > *)jarg1;
30035   arg2 = (Dali::Vector< int >::Iterator)jarg2;
30036   {
30037     try {
30038       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2);
30039     } CALL_CATCH_EXCEPTION(0);
30040   }
30041
30042   jresult = (void *)result;
30043   return jresult;
30044 }
30045
30046
30047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
30048   void * jresult ;
30049   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
30050   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
30051   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
30052   Dali::Vector< int >::Iterator result;
30053
30054   arg1 = (Dali::Vector< int > *)jarg1;
30055   arg2 = (Dali::Vector< int >::Iterator)jarg2;
30056   arg3 = (Dali::Vector< int >::Iterator)jarg3;
30057   {
30058     try {
30059       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3);
30060     } CALL_CATCH_EXCEPTION(0);
30061   }
30062
30063   jresult = (void *)result;
30064   return jresult;
30065 }
30066
30067
30068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Remove(void * jarg1, void * jarg2) {
30069   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
30070   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
30071
30072   arg1 = (Dali::Vector< int > *)jarg1;
30073   arg2 = (Dali::Vector< int >::Iterator)jarg2;
30074   {
30075     try {
30076       (arg1)->Remove(arg2);
30077     } CALL_CATCH_EXCEPTION();
30078   }
30079
30080 }
30081
30082
30083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Swap(void * jarg1, void * jarg2) {
30084   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
30085   Dali::Vector< int > *arg2 = 0 ;
30086
30087   arg1 = (Dali::Vector< int > *)jarg1;
30088   arg2 = (Dali::Vector< int > *)jarg2;
30089   if (!arg2) {
30090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0);
30091     return ;
30092   }
30093   {
30094     try {
30095       (arg1)->Swap(*arg2);
30096     } CALL_CATCH_EXCEPTION();
30097   }
30098
30099 }
30100
30101
30102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Clear(void * jarg1) {
30103   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
30104
30105   arg1 = (Dali::Vector< int > *)jarg1;
30106   {
30107     try {
30108       (arg1)->Clear();
30109     } CALL_CATCH_EXCEPTION();
30110   }
30111
30112 }
30113
30114
30115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Release(void * jarg1) {
30116   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
30117
30118   arg1 = (Dali::Vector< int > *)jarg1;
30119   {
30120     try {
30121       (arg1)->Release();
30122     } CALL_CATCH_EXCEPTION();
30123   }
30124
30125 }
30126
30127
30128 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorFloat_BaseType_get() {
30129   int jresult ;
30130   int result;
30131
30132   result = (int)Dali::Vector< float >::BaseType;
30133   jresult = (int)result;
30134   return jresult;
30135 }
30136
30137
30138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_0() {
30139   void * jresult ;
30140   Dali::Vector< float > *result = 0 ;
30141
30142   {
30143     try {
30144       result = (Dali::Vector< float > *)new Dali::Vector< float >();
30145     } CALL_CATCH_EXCEPTION(0);
30146   }
30147
30148   jresult = (void *)result;
30149   return jresult;
30150 }
30151
30152
30153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorFloat(void * jarg1) {
30154   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30155
30156   arg1 = (Dali::Vector< float > *)jarg1;
30157   {
30158     try {
30159       delete arg1;
30160     } CALL_CATCH_EXCEPTION();
30161   }
30162
30163 }
30164
30165
30166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_1(void * jarg1) {
30167   void * jresult ;
30168   Dali::Vector< float > *arg1 = 0 ;
30169   Dali::Vector< float > *result = 0 ;
30170
30171   arg1 = (Dali::Vector< float > *)jarg1;
30172   if (!arg1) {
30173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
30174     return 0;
30175   }
30176   {
30177     try {
30178       result = (Dali::Vector< float > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1);
30179     } CALL_CATCH_EXCEPTION(0);
30180   }
30181
30182   jresult = (void *)result;
30183   return jresult;
30184 }
30185
30186
30187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Assign(void * jarg1, void * jarg2) {
30188   void * jresult ;
30189   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30190   Dali::Vector< float > *arg2 = 0 ;
30191   Dali::Vector< float > *result = 0 ;
30192
30193   arg1 = (Dali::Vector< float > *)jarg1;
30194   arg2 = (Dali::Vector< float > *)jarg2;
30195   if (!arg2) {
30196     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
30197     return 0;
30198   }
30199   {
30200     try {
30201       result = (Dali::Vector< float > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2);
30202     } CALL_CATCH_EXCEPTION(0);
30203   }
30204
30205   jresult = (void *)result;
30206   return jresult;
30207 }
30208
30209
30210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Begin(void * jarg1) {
30211   void * jresult ;
30212   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30213   Dali::Vector< float >::Iterator result;
30214
30215   arg1 = (Dali::Vector< float > *)jarg1;
30216   {
30217     try {
30218       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin();
30219     } CALL_CATCH_EXCEPTION(0);
30220   }
30221
30222   jresult = (void *)result;
30223   return jresult;
30224 }
30225
30226
30227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_End(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)->End();
30236     } CALL_CATCH_EXCEPTION(0);
30237   }
30238
30239   jresult = (void *)result;
30240   return jresult;
30241 }
30242
30243
30244 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
30245   void * jresult ;
30246   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30247   Dali::Vector< float >::SizeType arg2 ;
30248   Dali::Vector< float >::ItemType *result = 0 ;
30249
30250   arg1 = (Dali::Vector< float > *)jarg1;
30251   arg2 = (Dali::Vector< float >::SizeType)jarg2;
30252   {
30253     try {
30254       result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2);
30255     } CALL_CATCH_EXCEPTION(0);
30256   }
30257
30258   jresult = (void *)result;
30259   return jresult;
30260 }
30261
30262
30263 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_PushBack(void * jarg1, float jarg2) {
30264   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30265   Dali::Vector< float >::ItemType *arg2 = 0 ;
30266   Dali::Vector< float >::ItemType temp2 ;
30267
30268   arg1 = (Dali::Vector< float > *)jarg1;
30269   temp2 = (Dali::Vector< float >::ItemType)jarg2;
30270   arg2 = &temp2;
30271   {
30272     try {
30273       (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2);
30274     } CALL_CATCH_EXCEPTION();
30275   }
30276
30277 }
30278
30279
30280 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) {
30281   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30282   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
30283   Dali::Vector< float >::ItemType *arg3 = 0 ;
30284   Dali::Vector< float >::ItemType temp3 ;
30285
30286   arg1 = (Dali::Vector< float > *)jarg1;
30287   arg2 = (Dali::Vector< float >::Iterator)jarg2;
30288   temp3 = (Dali::Vector< float >::ItemType)jarg3;
30289   arg3 = &temp3;
30290   {
30291     try {
30292       (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
30293     } CALL_CATCH_EXCEPTION();
30294   }
30295
30296 }
30297
30298
30299 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
30300   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30301   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
30302   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
30303   Dali::Vector< float >::Iterator arg4 = (Dali::Vector< float >::Iterator) 0 ;
30304
30305   arg1 = (Dali::Vector< float > *)jarg1;
30306   arg2 = (Dali::Vector< float >::Iterator)jarg2;
30307   arg3 = (Dali::Vector< float >::Iterator)jarg3;
30308   arg4 = (Dali::Vector< float >::Iterator)jarg4;
30309   {
30310     try {
30311       (arg1)->Insert(arg2,arg3,arg4);
30312     } CALL_CATCH_EXCEPTION();
30313   }
30314
30315 }
30316
30317
30318 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) {
30319   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30320   Dali::Vector< float >::SizeType arg2 ;
30321
30322   arg1 = (Dali::Vector< float > *)jarg1;
30323   arg2 = (Dali::Vector< float >::SizeType)jarg2;
30324   {
30325     try {
30326       (arg1)->Reserve(arg2);
30327     } CALL_CATCH_EXCEPTION();
30328   }
30329
30330 }
30331
30332 //// ========================= end of part 2 =============================
30333
30334 //// ========================== start part 3 ===============================
30335
30336
30337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
30338   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30339   Dali::Vector< float >::SizeType arg2 ;
30340
30341   arg1 = (Dali::Vector< float > *)jarg1;
30342   arg2 = (Dali::Vector< float >::SizeType)jarg2;
30343   {
30344     try {
30345       (arg1)->Resize(arg2);
30346     } CALL_CATCH_EXCEPTION();
30347   }
30348
30349 }
30350
30351
30352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) {
30353   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30354   Dali::Vector< float >::SizeType arg2 ;
30355   Dali::Vector< float >::ItemType *arg3 = 0 ;
30356   Dali::Vector< float >::ItemType temp3 ;
30357
30358   arg1 = (Dali::Vector< float > *)jarg1;
30359   arg2 = (Dali::Vector< float >::SizeType)jarg2;
30360   temp3 = (Dali::Vector< float >::ItemType)jarg3;
30361   arg3 = &temp3;
30362   {
30363     try {
30364       (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
30365     } CALL_CATCH_EXCEPTION();
30366   }
30367
30368 }
30369
30370
30371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) {
30372   void * jresult ;
30373   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30374   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
30375   Dali::Vector< float >::Iterator result;
30376
30377   arg1 = (Dali::Vector< float > *)jarg1;
30378   arg2 = (Dali::Vector< float >::Iterator)jarg2;
30379   {
30380     try {
30381       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2);
30382     } CALL_CATCH_EXCEPTION(0);
30383   }
30384
30385   jresult = (void *)result;
30386   return jresult;
30387 }
30388
30389
30390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
30391   void * jresult ;
30392   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30393   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
30394   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
30395   Dali::Vector< float >::Iterator result;
30396
30397   arg1 = (Dali::Vector< float > *)jarg1;
30398   arg2 = (Dali::Vector< float >::Iterator)jarg2;
30399   arg3 = (Dali::Vector< float >::Iterator)jarg3;
30400   {
30401     try {
30402       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3);
30403     } CALL_CATCH_EXCEPTION(0);
30404   }
30405
30406   jresult = (void *)result;
30407   return jresult;
30408 }
30409
30410
30411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Remove(void * jarg1, void * jarg2) {
30412   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30413   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
30414
30415   arg1 = (Dali::Vector< float > *)jarg1;
30416   arg2 = (Dali::Vector< float >::Iterator)jarg2;
30417   {
30418     try {
30419       (arg1)->Remove(arg2);
30420     } CALL_CATCH_EXCEPTION();
30421   }
30422
30423 }
30424
30425
30426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Swap(void * jarg1, void * jarg2) {
30427   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30428   Dali::Vector< float > *arg2 = 0 ;
30429
30430   arg1 = (Dali::Vector< float > *)jarg1;
30431   arg2 = (Dali::Vector< float > *)jarg2;
30432   if (!arg2) {
30433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0);
30434     return ;
30435   }
30436   {
30437     try {
30438       (arg1)->Swap(*arg2);
30439     } CALL_CATCH_EXCEPTION();
30440   }
30441
30442 }
30443
30444
30445 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Clear(void * jarg1) {
30446   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30447
30448   arg1 = (Dali::Vector< float > *)jarg1;
30449   {
30450     try {
30451       (arg1)->Clear();
30452     } CALL_CATCH_EXCEPTION();
30453   }
30454
30455 }
30456
30457
30458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Release(void * jarg1) {
30459   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
30460
30461   arg1 = (Dali::Vector< float > *)jarg1;
30462   {
30463     try {
30464       (arg1)->Release();
30465     } CALL_CATCH_EXCEPTION();
30466   }
30467
30468 }
30469
30470
30471 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_BaseType_get() {
30472   int jresult ;
30473   int result;
30474
30475   result = (int)Dali::Vector< unsigned char >::BaseType;
30476   jresult = (int)result;
30477   return jresult;
30478 }
30479
30480
30481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_0() {
30482   void * jresult ;
30483   Dali::Vector< unsigned char > *result = 0 ;
30484
30485   {
30486     try {
30487       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >();
30488     } CALL_CATCH_EXCEPTION(0);
30489   }
30490
30491   jresult = (void *)result;
30492   return jresult;
30493 }
30494
30495
30496 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUnsignedChar(void * jarg1) {
30497   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30498
30499   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30500   {
30501     try {
30502       delete arg1;
30503     } CALL_CATCH_EXCEPTION();
30504   }
30505
30506 }
30507
30508
30509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_1(void * jarg1) {
30510   void * jresult ;
30511   Dali::Vector< unsigned char > *arg1 = 0 ;
30512   Dali::Vector< unsigned char > *result = 0 ;
30513
30514   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30515   if (!arg1) {
30516     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
30517     return 0;
30518   }
30519   {
30520     try {
30521       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > const &)*arg1);
30522     } CALL_CATCH_EXCEPTION(0);
30523   }
30524
30525   jresult = (void *)result;
30526   return jresult;
30527 }
30528
30529
30530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Assign(void * jarg1, void * jarg2) {
30531   void * jresult ;
30532   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30533   Dali::Vector< unsigned char > *arg2 = 0 ;
30534   Dali::Vector< unsigned char > *result = 0 ;
30535
30536   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30537   arg2 = (Dali::Vector< unsigned char > *)jarg2;
30538   if (!arg2) {
30539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
30540     return 0;
30541   }
30542   {
30543     try {
30544       result = (Dali::Vector< unsigned char > *) &(arg1)->operator =((Dali::Vector< unsigned char > const &)*arg2);
30545     } CALL_CATCH_EXCEPTION(0);
30546   }
30547
30548   jresult = (void *)result;
30549   return jresult;
30550 }
30551
30552
30553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Begin(void * jarg1) {
30554   void * jresult ;
30555   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30556   Dali::Vector< unsigned char >::Iterator result;
30557
30558   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30559   {
30560     try {
30561       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin();
30562     } CALL_CATCH_EXCEPTION(0);
30563   }
30564
30565   jresult = (void *)result;
30566   return jresult;
30567 }
30568
30569
30570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_End(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)->End();
30579     } CALL_CATCH_EXCEPTION(0);
30580   }
30581
30582   jresult = (void *)result;
30583   return jresult;
30584 }
30585
30586
30587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
30588   void * jresult ;
30589   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30590   Dali::Vector< unsigned char >::SizeType arg2 ;
30591   Dali::Vector< unsigned char >::ItemType *result = 0 ;
30592
30593   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30594   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
30595   {
30596     try {
30597       result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2);
30598     } CALL_CATCH_EXCEPTION(0);
30599   }
30600
30601   jresult = (void *)result;
30602   return jresult;
30603 }
30604
30605
30606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) {
30607   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30608   Dali::Vector< unsigned char >::ItemType *arg2 = 0 ;
30609   Dali::Vector< unsigned char >::ItemType temp2 ;
30610
30611   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30612   temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2;
30613   arg2 = &temp2;
30614   {
30615     try {
30616       (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2);
30617     } CALL_CATCH_EXCEPTION();
30618   }
30619
30620 }
30621
30622
30623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) {
30624   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30625   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
30626   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
30627   Dali::Vector< unsigned char >::ItemType temp3 ;
30628
30629   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30630   arg2 = jarg2;
30631   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
30632   arg3 = &temp3;
30633   {
30634     try {
30635       (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
30636     } CALL_CATCH_EXCEPTION();
30637   }
30638
30639
30640
30641 }
30642
30643
30644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) {
30645   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30646   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
30647   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
30648   Dali::Vector< unsigned char >::Iterator arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ;
30649
30650   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30651   arg2 = jarg2;
30652   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
30653   arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4;
30654   {
30655     try {
30656       (arg1)->Insert(arg2,arg3,arg4);
30657     } CALL_CATCH_EXCEPTION();
30658   }
30659
30660
30661
30662 }
30663
30664
30665 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Reserve(void * jarg1, unsigned long jarg2) {
30666   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30667   Dali::Vector< unsigned char >::SizeType arg2 ;
30668
30669   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30670   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
30671   {
30672     try {
30673       (arg1)->Reserve(arg2);
30674     } CALL_CATCH_EXCEPTION();
30675   }
30676
30677 }
30678
30679
30680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
30681   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30682   Dali::Vector< unsigned char >::SizeType arg2 ;
30683
30684   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30685   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
30686   {
30687     try {
30688       (arg1)->Resize(arg2);
30689     } CALL_CATCH_EXCEPTION();
30690   }
30691
30692 }
30693
30694
30695 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) {
30696   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30697   Dali::Vector< unsigned char >::SizeType arg2 ;
30698   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
30699   Dali::Vector< unsigned char >::ItemType temp3 ;
30700
30701   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30702   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
30703   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
30704   arg3 = &temp3;
30705   {
30706     try {
30707       (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
30708     } CALL_CATCH_EXCEPTION();
30709   }
30710
30711 }
30712
30713
30714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) {
30715   void * jresult ;
30716   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30717   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
30718   Dali::Vector< unsigned char >::Iterator result;
30719
30720   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30721   arg2 = jarg2;
30722   {
30723     try {
30724       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2);
30725     } CALL_CATCH_EXCEPTION(0);
30726   }
30727
30728   jresult = (void *)result;
30729
30730
30731   return jresult;
30732 }
30733
30734
30735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) {
30736   void * jresult ;
30737   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30738   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
30739   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
30740   Dali::Vector< unsigned char >::Iterator result;
30741
30742   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30743   arg2 = jarg2;
30744   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
30745   {
30746     try {
30747       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3);
30748     } CALL_CATCH_EXCEPTION(0);
30749   }
30750
30751   jresult = (void *)result;
30752
30753
30754   return jresult;
30755 }
30756
30757
30758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Remove(void * jarg1, unsigned char* jarg2) {
30759   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30760   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
30761
30762   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30763   arg2 = jarg2;
30764   {
30765     try {
30766       (arg1)->Remove(arg2);
30767     } CALL_CATCH_EXCEPTION();
30768   }
30769
30770
30771
30772 }
30773
30774
30775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) {
30776   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30777   Dali::Vector< unsigned char > *arg2 = 0 ;
30778
30779   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30780   arg2 = (Dali::Vector< unsigned char > *)jarg2;
30781   if (!arg2) {
30782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0);
30783     return ;
30784   }
30785   {
30786     try {
30787       (arg1)->Swap(*arg2);
30788     } CALL_CATCH_EXCEPTION();
30789   }
30790
30791 }
30792
30793
30794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Clear(void * jarg1) {
30795   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30796
30797   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30798   {
30799     try {
30800       (arg1)->Clear();
30801     } CALL_CATCH_EXCEPTION();
30802   }
30803
30804 }
30805
30806
30807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Release(void * jarg1) {
30808   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
30809
30810   arg1 = (Dali::Vector< unsigned char > *)jarg1;
30811   {
30812     try {
30813       (arg1)->Release();
30814     } CALL_CATCH_EXCEPTION();
30815   }
30816
30817 }
30818
30819
30820 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUint16Pair_BaseType_get() {
30821   int jresult ;
30822   int result;
30823
30824   result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType;
30825   jresult = (int)result;
30826   return jresult;
30827 }
30828
30829
30830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_0() {
30831   void * jresult ;
30832   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
30833
30834   {
30835     try {
30836       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >();
30837     } CALL_CATCH_EXCEPTION(0);
30838   }
30839
30840   jresult = (void *)result;
30841   return jresult;
30842 }
30843
30844
30845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUint16Pair(void * jarg1) {
30846   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
30847
30848   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
30849   {
30850     try {
30851       delete arg1;
30852     } CALL_CATCH_EXCEPTION();
30853   }
30854
30855 }
30856
30857
30858 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_1(void * jarg1) {
30859   void * jresult ;
30860   Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ;
30861   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
30862
30863   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
30864   if (!arg1) {
30865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
30866     return 0;
30867   }
30868   {
30869     try {
30870       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1);
30871     } CALL_CATCH_EXCEPTION(0);
30872   }
30873
30874   jresult = (void *)result;
30875   return jresult;
30876 }
30877
30878
30879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Assign(void * jarg1, void * jarg2) {
30880   void * jresult ;
30881   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
30882   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
30883   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
30884
30885   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
30886   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
30887   if (!arg2) {
30888     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
30889     return 0;
30890   }
30891   {
30892     try {
30893       result = (Dali::Vector< Dali::Uint16Pair > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2);
30894     } CALL_CATCH_EXCEPTION(0);
30895   }
30896
30897   jresult = (void *)result;
30898   return jresult;
30899 }
30900
30901
30902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Begin(void * jarg1) {
30903   void * jresult ;
30904   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
30905   Dali::Vector< Dali::Uint16Pair >::Iterator result;
30906
30907   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
30908   {
30909     try {
30910       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin();
30911     } CALL_CATCH_EXCEPTION(0);
30912   }
30913
30914   jresult = (void *)result;
30915   return jresult;
30916 }
30917
30918
30919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_End(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)->End();
30928     } CALL_CATCH_EXCEPTION(0);
30929   }
30930
30931   jresult = (void *)result;
30932   return jresult;
30933 }
30934
30935
30936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
30937   void * jresult ;
30938   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
30939   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
30940   Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ;
30941
30942   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
30943   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
30944   {
30945     try {
30946       result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2);
30947     } CALL_CATCH_EXCEPTION(0);
30948   }
30949
30950   jresult = (void *)result;
30951   return jresult;
30952 }
30953
30954
30955 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) {
30956   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
30957   Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ;
30958
30959   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
30960   arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2;
30961   if (!arg2) {
30962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
30963     return ;
30964   }
30965   {
30966     try {
30967       (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2);
30968     } CALL_CATCH_EXCEPTION();
30969   }
30970
30971 }
30972
30973
30974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
30975   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
30976   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
30977   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
30978
30979   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
30980   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
30981   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
30982   if (!arg3) {
30983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
30984     return ;
30985   }
30986   {
30987     try {
30988       (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
30989     } CALL_CATCH_EXCEPTION();
30990   }
30991
30992 }
30993
30994
30995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
30996   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
30997   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
30998   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
30999   Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
31000
31001   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
31002   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
31003   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
31004   arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4;
31005   {
31006     try {
31007       (arg1)->Insert(arg2,arg3,arg4);
31008     } CALL_CATCH_EXCEPTION();
31009   }
31010
31011 }
31012
31013
31014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) {
31015   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
31016   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
31017
31018   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
31019   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
31020   {
31021     try {
31022       (arg1)->Reserve(arg2);
31023     } CALL_CATCH_EXCEPTION();
31024   }
31025
31026 }
31027
31028
31029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
31030   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
31031   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
31032
31033   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
31034   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
31035   {
31036     try {
31037       (arg1)->Resize(arg2);
31038     } CALL_CATCH_EXCEPTION();
31039   }
31040
31041 }
31042
31043
31044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
31045   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
31046   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
31047   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
31048
31049   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
31050   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
31051   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
31052   if (!arg3) {
31053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
31054     return ;
31055   }
31056   {
31057     try {
31058       (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
31059     } CALL_CATCH_EXCEPTION();
31060   }
31061
31062 }
31063
31064
31065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_0(void * jarg1, void * jarg2) {
31066   void * jresult ;
31067   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
31068   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
31069   Dali::Vector< Dali::Uint16Pair >::Iterator result;
31070
31071   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
31072   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
31073   {
31074     try {
31075       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2);
31076     } CALL_CATCH_EXCEPTION(0);
31077   }
31078
31079   jresult = (void *)result;
31080   return jresult;
31081 }
31082
31083
31084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
31085   void * jresult ;
31086   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
31087   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
31088   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
31089   Dali::Vector< Dali::Uint16Pair >::Iterator result;
31090
31091   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
31092   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
31093   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
31094   {
31095     try {
31096       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3);
31097     } CALL_CATCH_EXCEPTION(0);
31098   }
31099
31100   jresult = (void *)result;
31101   return jresult;
31102 }
31103
31104
31105 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Remove(void * jarg1, void * jarg2) {
31106   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
31107   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
31108
31109   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
31110   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
31111   {
31112     try {
31113       (arg1)->Remove(arg2);
31114     } CALL_CATCH_EXCEPTION();
31115   }
31116
31117 }
31118
31119
31120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Swap(void * jarg1, void * jarg2) {
31121   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
31122   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
31123
31124   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
31125   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
31126   if (!arg2) {
31127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0);
31128     return ;
31129   }
31130   {
31131     try {
31132       (arg1)->Swap(*arg2);
31133     } CALL_CATCH_EXCEPTION();
31134   }
31135
31136 }
31137
31138
31139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Clear(void * jarg1) {
31140   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
31141
31142   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
31143   {
31144     try {
31145       (arg1)->Clear();
31146     } CALL_CATCH_EXCEPTION();
31147   }
31148
31149 }
31150
31151
31152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Release(void * jarg1) {
31153   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
31154
31155   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
31156   {
31157     try {
31158       (arg1)->Release();
31159     } CALL_CATCH_EXCEPTION();
31160   }
31161
31162 }
31163
31164
31165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignal() {
31166   void * jresult ;
31167   Dali::Signal< void () > *result = 0 ;
31168
31169   {
31170     try {
31171       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
31172     } CALL_CATCH_EXCEPTION(0);
31173   }
31174
31175   jresult = (void *)result;
31176   return jresult;
31177 }
31178
31179
31180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignal(void * jarg1) {
31181   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
31182
31183   arg1 = (Dali::Signal< void () > *)jarg1;
31184   {
31185     try {
31186       delete arg1;
31187     } CALL_CATCH_EXCEPTION();
31188   }
31189
31190 }
31191
31192
31193 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VoidSignal_Empty(void * jarg1) {
31194   unsigned int jresult ;
31195   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
31196   bool result;
31197
31198   arg1 = (Dali::Signal< void () > *)jarg1;
31199   {
31200     try {
31201       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
31202     } CALL_CATCH_EXCEPTION(0);
31203   }
31204
31205   jresult = result;
31206   return jresult;
31207 }
31208
31209
31210 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignal_GetConnectionCount(void * jarg1) {
31211   unsigned long jresult ;
31212   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
31213   std::size_t result;
31214
31215   arg1 = (Dali::Signal< void () > *)jarg1;
31216   {
31217     try {
31218       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
31219     } CALL_CATCH_EXCEPTION(0);
31220   }
31221
31222   jresult = (unsigned long)result;
31223   return jresult;
31224 }
31225
31226
31227 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
31228   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
31229   void (*arg2)() = (void (*)()) 0 ;
31230
31231   arg1 = (Dali::Signal< void () > *)jarg1;
31232   arg2 = (void (*)())jarg2;
31233   {
31234     try {
31235       (arg1)->Connect(arg2);
31236     } CALL_CATCH_EXCEPTION();
31237   }
31238
31239 }
31240
31241
31242 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Disconnect(void * jarg1, void * jarg2) {
31243   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
31244   void (*arg2)() = (void (*)()) 0 ;
31245
31246   arg1 = (Dali::Signal< void () > *)jarg1;
31247   arg2 = (void (*)())jarg2;
31248   {
31249     try {
31250       (arg1)->Disconnect(arg2);
31251     } CALL_CATCH_EXCEPTION();
31252   }
31253
31254 }
31255
31256
31257 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
31258   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
31259   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
31260   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
31261
31262   arg1 = (Dali::Signal< void () > *)jarg1;
31263   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
31264   arg3 = (Dali::FunctorDelegate *)jarg3;
31265   {
31266     try {
31267       (arg1)->Connect(arg2,arg3);
31268     } CALL_CATCH_EXCEPTION();
31269   }
31270
31271 }
31272
31273
31274 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Emit(void * jarg1) {
31275   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
31276
31277   arg1 = (Dali::Signal< void () > *)jarg1;
31278   {
31279     try {
31280       (arg1)->Emit();
31281     } CALL_CATCH_EXCEPTION();
31282   }
31283
31284 }
31285
31286
31287 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FloatSignal_Empty(void * jarg1) {
31288   unsigned int jresult ;
31289   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
31290   bool result;
31291
31292   arg1 = (Dali::Signal< void (float) > *)jarg1;
31293   {
31294     try {
31295       result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1);
31296     } CALL_CATCH_EXCEPTION(0);
31297   }
31298
31299   jresult = result;
31300   return jresult;
31301 }
31302
31303
31304 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FloatSignal_GetConnectionCount(void * jarg1) {
31305   unsigned long jresult ;
31306   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
31307   std::size_t result;
31308
31309   arg1 = (Dali::Signal< void (float) > *)jarg1;
31310   {
31311     try {
31312       result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1);
31313     } CALL_CATCH_EXCEPTION(0);
31314   }
31315
31316   jresult = (unsigned long)result;
31317   return jresult;
31318 }
31319
31320
31321 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Connect(void * jarg1, void * jarg2) {
31322   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
31323   void (*arg2)(float) = (void (*)(float)) 0 ;
31324
31325   arg1 = (Dali::Signal< void (float) > *)jarg1;
31326   arg2 = (void (*)(float))jarg2;
31327   {
31328     try {
31329       Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2);
31330     } CALL_CATCH_EXCEPTION();
31331   }
31332
31333 }
31334
31335
31336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Disconnect(void * jarg1, void * jarg2) {
31337   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
31338   void (*arg2)(float) = (void (*)(float)) 0 ;
31339
31340   arg1 = (Dali::Signal< void (float) > *)jarg1;
31341   arg2 = (void (*)(float))jarg2;
31342   {
31343     try {
31344       Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(arg1,arg2);
31345     } CALL_CATCH_EXCEPTION();
31346   }
31347
31348 }
31349
31350
31351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Emit(void * jarg1, float jarg2) {
31352   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
31353   float arg2 ;
31354
31355   arg1 = (Dali::Signal< void (float) > *)jarg1;
31356   arg2 = (float)jarg2;
31357   {
31358     try {
31359       Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(arg1,arg2);
31360     } CALL_CATCH_EXCEPTION();
31361   }
31362
31363 }
31364
31365
31366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FloatSignal() {
31367   void * jresult ;
31368   Dali::Signal< void (float) > *result = 0 ;
31369
31370   {
31371     try {
31372       result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >();
31373     } CALL_CATCH_EXCEPTION(0);
31374   }
31375
31376   jresult = (void *)result;
31377   return jresult;
31378 }
31379
31380
31381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FloatSignal(void * jarg1) {
31382   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
31383
31384   arg1 = (Dali::Signal< void (float) > *)jarg1;
31385   {
31386     try {
31387       delete arg1;
31388     } CALL_CATCH_EXCEPTION();
31389   }
31390
31391 }
31392
31393
31394 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Empty(void * jarg1) {
31395   unsigned int jresult ;
31396   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
31397   bool result;
31398
31399   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
31400   {
31401     try {
31402       result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
31403     } CALL_CATCH_EXCEPTION(0);
31404   }
31405
31406   jresult = result;
31407   return jresult;
31408 }
31409
31410
31411 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_GetConnectionCount(void * jarg1) {
31412   unsigned long jresult ;
31413   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
31414   std::size_t result;
31415
31416   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
31417   {
31418     try {
31419       result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
31420     } CALL_CATCH_EXCEPTION(0);
31421   }
31422
31423   jresult = (unsigned long)result;
31424   return jresult;
31425 }
31426
31427
31428 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) {
31429   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
31430   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
31431
31432   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
31433   arg2 = (void (*)(Dali::BaseHandle))jarg2;
31434   {
31435     try {
31436       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2);
31437     } CALL_CATCH_EXCEPTION();
31438   }
31439
31440 }
31441
31442
31443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) {
31444   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
31445   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
31446
31447   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
31448   arg2 = (void (*)(Dali::BaseHandle))jarg2;
31449   {
31450     try {
31451       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2);
31452     } CALL_CATCH_EXCEPTION();
31453   }
31454
31455 }
31456
31457
31458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) {
31459   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
31460   Dali::BaseHandle arg2 ;
31461   Dali::BaseHandle *argp2 ;
31462
31463   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
31464   argp2 = (Dali::BaseHandle *)jarg2;
31465   if (!argp2) {
31466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
31467     return ;
31468   }
31469   arg2 = *argp2;
31470   {
31471     try {
31472       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(arg1,arg2);
31473     } CALL_CATCH_EXCEPTION();
31474   }
31475
31476 }
31477
31478
31479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectCreatedSignal() {
31480   void * jresult ;
31481   Dali::Signal< void (Dali::BaseHandle) > *result = 0 ;
31482
31483   {
31484     try {
31485       result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >();
31486     } CALL_CATCH_EXCEPTION(0);
31487   }
31488
31489   jresult = (void *)result;
31490   return jresult;
31491 }
31492
31493
31494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectCreatedSignal(void * jarg1) {
31495   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
31496
31497   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
31498   {
31499     try {
31500       delete arg1;
31501     } CALL_CATCH_EXCEPTION();
31502   }
31503
31504 }
31505
31506
31507 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Empty(void * jarg1) {
31508   unsigned int jresult ;
31509   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
31510   bool result;
31511
31512   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
31513   {
31514     try {
31515       result = (bool)Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
31516     } CALL_CATCH_EXCEPTION(0);
31517   }
31518
31519   jresult = result;
31520   return jresult;
31521 }
31522
31523
31524 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_GetConnectionCount(void * jarg1) {
31525   unsigned long jresult ;
31526   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
31527   std::size_t result;
31528
31529   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
31530   {
31531     try {
31532       result = Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
31533     } CALL_CATCH_EXCEPTION(0);
31534   }
31535
31536   jresult = (unsigned long)result;
31537   return jresult;
31538 }
31539
31540
31541 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Connect(void * jarg1, void * jarg2) {
31542   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
31543   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
31544
31545   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
31546   arg2 = (void (*)(Dali::RefObject const *))jarg2;
31547   {
31548     try {
31549       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(arg1,arg2);
31550     } CALL_CATCH_EXCEPTION();
31551   }
31552
31553 }
31554
31555
31556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Disconnect(void * jarg1, void * jarg2) {
31557   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
31558   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
31559
31560   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
31561   arg2 = (void (*)(Dali::RefObject const *))jarg2;
31562   {
31563     try {
31564       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(arg1,arg2);
31565     } CALL_CATCH_EXCEPTION();
31566   }
31567
31568 }
31569
31570
31571 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Emit(void * jarg1, void * jarg2) {
31572   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
31573   Dali::RefObject *arg2 = (Dali::RefObject *) 0 ;
31574
31575   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
31576   arg2 = (Dali::RefObject *)jarg2;
31577   {
31578     try {
31579       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(arg1,(Dali::RefObject const *)arg2);
31580     } CALL_CATCH_EXCEPTION();
31581   }
31582
31583 }
31584
31585
31586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectDestroyedSignal() {
31587   void * jresult ;
31588   Dali::Signal< void (Dali::RefObject const *) > *result = 0 ;
31589
31590   {
31591     try {
31592       result = (Dali::Signal< void (Dali::RefObject const *) > *)new Dali::Signal< void (Dali::RefObject const *) >();
31593     } CALL_CATCH_EXCEPTION(0);
31594   }
31595
31596   jresult = (void *)result;
31597   return jresult;
31598 }
31599
31600
31601 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectDestroyedSignal(void * jarg1) {
31602   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
31603
31604   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
31605   {
31606     try {
31607       delete arg1;
31608     } CALL_CATCH_EXCEPTION();
31609   }
31610
31611 }
31612
31613
31614 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Empty(void * jarg1) {
31615   unsigned int jresult ;
31616   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
31617   bool result;
31618
31619   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
31620   {
31621     try {
31622       result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
31623     } CALL_CATCH_EXCEPTION(0);
31624   }
31625
31626   jresult = result;
31627   return jresult;
31628 }
31629
31630
31631 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_GetConnectionCount(void * jarg1) {
31632   unsigned long jresult ;
31633   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
31634   std::size_t result;
31635
31636   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
31637   {
31638     try {
31639       result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
31640     } CALL_CATCH_EXCEPTION(0);
31641   }
31642
31643   jresult = (unsigned long)result;
31644   return jresult;
31645 }
31646
31647
31648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) {
31649   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
31650   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
31651
31652   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
31653   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
31654   {
31655     try {
31656       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2);
31657     } CALL_CATCH_EXCEPTION();
31658   }
31659
31660 }
31661
31662
31663 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) {
31664   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
31665   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
31666
31667   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
31668   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
31669   {
31670     try {
31671       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2);
31672     } CALL_CATCH_EXCEPTION();
31673   }
31674
31675 }
31676
31677
31678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) {
31679   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
31680   Dali::PropertyNotification *arg2 = 0 ;
31681
31682   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
31683   arg2 = (Dali::PropertyNotification *)jarg2;
31684   if (!arg2) {
31685     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0);
31686     return ;
31687   }
31688   {
31689     try {
31690       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(arg1,*arg2);
31691     } CALL_CATCH_EXCEPTION();
31692   }
31693
31694 }
31695
31696
31697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotifySignal() {
31698   void * jresult ;
31699   Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ;
31700
31701   {
31702     try {
31703       result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >();
31704     } CALL_CATCH_EXCEPTION(0);
31705   }
31706
31707   jresult = (void *)result;
31708   return jresult;
31709 }
31710
31711
31712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotifySignal(void * jarg1) {
31713   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
31714
31715   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
31716   {
31717     try {
31718       delete arg1;
31719     } CALL_CATCH_EXCEPTION();
31720   }
31721
31722 }
31723
31724
31725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskSignal() {
31726   void * jresult ;
31727   Dali::Signal< void (Dali::RenderTask &) > *result = 0 ;
31728
31729   {
31730     try {
31731       result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >();
31732     } CALL_CATCH_EXCEPTION(0);
31733   }
31734
31735   jresult = (void *)result;
31736   return jresult;
31737 }
31738
31739
31740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskSignal(void * jarg1) {
31741   Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ;
31742
31743   arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1;
31744   {
31745     try {
31746       delete arg1;
31747     } CALL_CATCH_EXCEPTION();
31748   }
31749
31750 }
31751
31752
31753 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Empty(void * jarg1) {
31754   unsigned int jresult ;
31755   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
31756   bool result;
31757
31758   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
31759   {
31760     try {
31761       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);
31762     } CALL_CATCH_EXCEPTION(0);
31763   }
31764
31765   jresult = result;
31766   return jresult;
31767 }
31768
31769
31770 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) {
31771   unsigned long jresult ;
31772   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
31773   std::size_t result;
31774
31775   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
31776   {
31777     try {
31778       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);
31779     } CALL_CATCH_EXCEPTION(0);
31780   }
31781
31782   jresult = (unsigned long)result;
31783   return jresult;
31784 }
31785
31786
31787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
31788   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
31789   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
31790
31791   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
31792   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
31793   {
31794     try {
31795       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
31796     } CALL_CATCH_EXCEPTION();
31797   }
31798
31799 }
31800
31801
31802 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
31803   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
31804   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
31805
31806   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
31807   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
31808   {
31809     try {
31810       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
31811     } CALL_CATCH_EXCEPTION();
31812   }
31813
31814 }
31815
31816
31817 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
31818   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
31819   Dali::Actor arg2 ;
31820   Dali::LongPressGesture *arg3 = 0 ;
31821   Dali::Actor *argp2 ;
31822
31823   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
31824   argp2 = (Dali::Actor *)jarg2;
31825   if (!argp2) {
31826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
31827     return ;
31828   }
31829   arg2 = *argp2;
31830   arg3 = (Dali::LongPressGesture *)jarg3;
31831   if (!arg3) {
31832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
31833     return ;
31834   }
31835   {
31836     try {
31837       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture const &)*arg3);
31838     } CALL_CATCH_EXCEPTION();
31839   }
31840
31841 }
31842
31843
31844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetectedSignal() {
31845   void * jresult ;
31846   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ;
31847
31848   {
31849     try {
31850       result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >();
31851     } CALL_CATCH_EXCEPTION(0);
31852   }
31853
31854   jresult = (void *)result;
31855   return jresult;
31856 }
31857
31858
31859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetectedSignal(void * jarg1) {
31860   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
31861
31862   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
31863   {
31864     try {
31865       delete arg1;
31866     } CALL_CATCH_EXCEPTION();
31867   }
31868
31869 }
31870
31871
31872 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Empty(void * jarg1) {
31873   unsigned int jresult ;
31874   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
31875   bool result;
31876
31877   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
31878   {
31879     try {
31880       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);
31881     } CALL_CATCH_EXCEPTION(0);
31882   }
31883
31884   jresult = result;
31885   return jresult;
31886 }
31887
31888
31889 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_GetConnectionCount(void * jarg1) {
31890   unsigned long jresult ;
31891   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
31892   std::size_t result;
31893
31894   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
31895   {
31896     try {
31897       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);
31898     } CALL_CATCH_EXCEPTION(0);
31899   }
31900
31901   jresult = (unsigned long)result;
31902   return jresult;
31903 }
31904
31905
31906 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Connect(void * jarg1, void * jarg2) {
31907   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
31908   bool (*arg2)(Dali::Actor,Dali::TouchEvent const &) = (bool (*)(Dali::Actor,Dali::TouchEvent const &)) 0 ;
31909
31910   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
31911   arg2 = (bool (*)(Dali::Actor,Dali::TouchEvent const &))jarg2;
31912   {
31913     try {
31914       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
31915     } CALL_CATCH_EXCEPTION();
31916   }
31917
31918 }
31919
31920
31921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Disconnect(void * jarg1, void * jarg2) {
31922   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
31923   bool (*arg2)(Dali::Actor,Dali::TouchEvent const &) = (bool (*)(Dali::Actor,Dali::TouchEvent const &)) 0 ;
31924
31925   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
31926   arg2 = (bool (*)(Dali::Actor,Dali::TouchEvent const &))jarg2;
31927   {
31928     try {
31929       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
31930     } CALL_CATCH_EXCEPTION();
31931   }
31932
31933 }
31934
31935
31936 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
31937   unsigned int jresult ;
31938   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
31939   Dali::Actor arg2 ;
31940   Dali::TouchEvent *arg3 = 0 ;
31941   Dali::Actor *argp2 ;
31942   bool result;
31943
31944   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
31945   argp2 = (Dali::Actor *)jarg2;
31946   if (!argp2) {
31947     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
31948     return 0;
31949   }
31950   arg2 = *argp2;
31951   arg3 = (Dali::TouchEvent *)jarg3;
31952   if (!arg3) {
31953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
31954     return 0;
31955   }
31956   {
31957     try {
31958       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TouchEvent const &)*arg3);
31959     } CALL_CATCH_EXCEPTION(0);
31960   }
31961
31962   jresult = result;
31963   return jresult;
31964 }
31965
31966
31967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorTouchDataSignal() {
31968   void * jresult ;
31969   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *result = 0 ;
31970
31971   {
31972     try {
31973       result = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) >();
31974     } CALL_CATCH_EXCEPTION(0);
31975   }
31976
31977   jresult = (void *)result;
31978   return jresult;
31979 }
31980
31981
31982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorTouchDataSignal(void * jarg1) {
31983   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
31984
31985   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
31986   {
31987     try {
31988       delete arg1;
31989     } CALL_CATCH_EXCEPTION();
31990   }
31991
31992 }
31993
31994
31995 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Empty(void * jarg1) {
31996   unsigned int jresult ;
31997   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
31998   bool result;
31999
32000   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
32001   {
32002     try {
32003       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);
32004     } CALL_CATCH_EXCEPTION(0);
32005   }
32006
32007   jresult = result;
32008   return jresult;
32009 }
32010
32011
32012 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorHoverSignal_GetConnectionCount(void * jarg1) {
32013   unsigned long jresult ;
32014   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
32015   std::size_t result;
32016
32017   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
32018   {
32019     try {
32020       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);
32021     } CALL_CATCH_EXCEPTION(0);
32022   }
32023
32024   jresult = (unsigned long)result;
32025   return jresult;
32026 }
32027
32028
32029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Connect(void * jarg1, void * jarg2) {
32030   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
32031   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
32032
32033   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
32034   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
32035   {
32036     try {
32037       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
32038     } CALL_CATCH_EXCEPTION();
32039   }
32040
32041 }
32042
32043
32044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Disconnect(void * jarg1, void * jarg2) {
32045   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
32046   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
32047
32048   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
32049   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
32050   {
32051     try {
32052       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
32053     } CALL_CATCH_EXCEPTION();
32054   }
32055
32056 }
32057
32058
32059 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
32060   unsigned int jresult ;
32061   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
32062   Dali::Actor arg2 ;
32063   Dali::HoverEvent *arg3 = 0 ;
32064   Dali::Actor *argp2 ;
32065   bool result;
32066
32067   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
32068   argp2 = (Dali::Actor *)jarg2;
32069   if (!argp2) {
32070     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32071     return 0;
32072   }
32073   arg2 = *argp2;
32074   arg3 = (Dali::HoverEvent *)jarg3;
32075   if (!arg3) {
32076     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
32077     return 0;
32078   }
32079   {
32080     try {
32081       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::HoverEvent const &)*arg3);
32082     } CALL_CATCH_EXCEPTION(0);
32083   }
32084
32085   jresult = result;
32086   return jresult;
32087 }
32088
32089
32090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorHoverSignal() {
32091   void * jresult ;
32092   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *result = 0 ;
32093
32094   {
32095     try {
32096       result = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) >();
32097     } CALL_CATCH_EXCEPTION(0);
32098   }
32099
32100   jresult = (void *)result;
32101   return jresult;
32102 }
32103
32104
32105 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorHoverSignal(void * jarg1) {
32106   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
32107
32108   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
32109   {
32110     try {
32111       delete arg1;
32112     } CALL_CATCH_EXCEPTION();
32113   }
32114
32115 }
32116
32117
32118 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Empty(void * jarg1) {
32119   unsigned int jresult ;
32120   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
32121   bool result;
32122
32123   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
32124   {
32125     try {
32126       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);
32127     } CALL_CATCH_EXCEPTION(0);
32128   }
32129
32130   jresult = result;
32131   return jresult;
32132 }
32133
32134
32135 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorWheelSignal_GetConnectionCount(void * jarg1) {
32136   unsigned long jresult ;
32137   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
32138   std::size_t result;
32139
32140   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
32141   {
32142     try {
32143       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);
32144     } CALL_CATCH_EXCEPTION(0);
32145   }
32146
32147   jresult = (unsigned long)result;
32148   return jresult;
32149 }
32150
32151
32152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Connect(void * jarg1, void * jarg2) {
32153   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
32154   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
32155
32156   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
32157   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
32158   {
32159     try {
32160       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
32161     } CALL_CATCH_EXCEPTION();
32162   }
32163
32164 }
32165
32166
32167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Disconnect(void * jarg1, void * jarg2) {
32168   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
32169   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
32170
32171   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
32172   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
32173   {
32174     try {
32175       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
32176     } CALL_CATCH_EXCEPTION();
32177   }
32178
32179 }
32180
32181
32182 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
32183   unsigned int jresult ;
32184   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
32185   Dali::Actor arg2 ;
32186   Dali::WheelEvent *arg3 = 0 ;
32187   Dali::Actor *argp2 ;
32188   bool result;
32189
32190   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
32191   argp2 = (Dali::Actor *)jarg2;
32192   if (!argp2) {
32193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32194     return 0;
32195   }
32196   arg2 = *argp2;
32197   arg3 = (Dali::WheelEvent *)jarg3;
32198   if (!arg3) {
32199     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
32200     return 0;
32201   }
32202   {
32203     try {
32204       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::WheelEvent const &)*arg3);
32205     } CALL_CATCH_EXCEPTION(0);
32206   }
32207
32208   jresult = result;
32209   return jresult;
32210 }
32211
32212
32213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorWheelSignal() {
32214   void * jresult ;
32215   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *result = 0 ;
32216
32217   {
32218     try {
32219       result = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) >();
32220     } CALL_CATCH_EXCEPTION(0);
32221   }
32222
32223   jresult = (void *)result;
32224   return jresult;
32225 }
32226
32227
32228 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorWheelSignal(void * jarg1) {
32229   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
32230
32231   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
32232   {
32233     try {
32234       delete arg1;
32235     } CALL_CATCH_EXCEPTION();
32236   }
32237
32238 }
32239
32240
32241 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorSignal_Empty(void * jarg1) {
32242   unsigned int jresult ;
32243   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
32244   bool result;
32245
32246   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
32247   {
32248     try {
32249       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor) > const *)arg1);
32250     } CALL_CATCH_EXCEPTION(0);
32251   }
32252
32253   jresult = result;
32254   return jresult;
32255 }
32256
32257
32258 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorSignal_GetConnectionCount(void * jarg1) {
32259   unsigned long jresult ;
32260   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
32261   std::size_t result;
32262
32263   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
32264   {
32265     try {
32266       result = Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor) > const *)arg1);
32267     } CALL_CATCH_EXCEPTION(0);
32268   }
32269
32270   jresult = (unsigned long)result;
32271   return jresult;
32272 }
32273
32274
32275 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Connect(void * jarg1, void * jarg2) {
32276   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
32277   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
32278
32279   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
32280   arg2 = (void (*)(Dali::Actor))jarg2;
32281   {
32282     try {
32283       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(arg1,arg2);
32284     } CALL_CATCH_EXCEPTION();
32285   }
32286
32287 }
32288
32289
32290 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Disconnect(void * jarg1, void * jarg2) {
32291   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
32292   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
32293
32294   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
32295   arg2 = (void (*)(Dali::Actor))jarg2;
32296   {
32297     try {
32298       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
32299     } CALL_CATCH_EXCEPTION();
32300   }
32301
32302 }
32303
32304
32305 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Emit(void * jarg1, void * jarg2) {
32306   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
32307   Dali::Actor arg2 ;
32308   Dali::Actor *argp2 ;
32309
32310   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
32311   argp2 = (Dali::Actor *)jarg2;
32312   if (!argp2) {
32313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32314     return ;
32315   }
32316   arg2 = *argp2;
32317   {
32318     try {
32319       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(arg1,arg2);
32320     } CALL_CATCH_EXCEPTION();
32321   }
32322
32323 }
32324
32325
32326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorSignal() {
32327   void * jresult ;
32328   Dali::Signal< void (Dali::Actor) > *result = 0 ;
32329
32330   {
32331     try {
32332       result = (Dali::Signal< void (Dali::Actor) > *)new Dali::Signal< void (Dali::Actor) >();
32333     } CALL_CATCH_EXCEPTION(0);
32334   }
32335
32336   jresult = (void *)result;
32337   return jresult;
32338 }
32339
32340
32341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorSignal(void * jarg1) {
32342   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
32343
32344   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
32345   {
32346     try {
32347       delete arg1;
32348     } CALL_CATCH_EXCEPTION();
32349   }
32350
32351 }
32352
32353
32354 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyEventSignal_Empty(void * jarg1) {
32355   unsigned int jresult ;
32356   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
32357   bool result;
32358
32359   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
32360   {
32361     try {
32362       result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
32363     } CALL_CATCH_EXCEPTION(0);
32364   }
32365
32366   jresult = result;
32367   return jresult;
32368 }
32369
32370
32371 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyEventSignal_GetConnectionCount(void * jarg1) {
32372   unsigned long jresult ;
32373   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
32374   std::size_t result;
32375
32376   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
32377   {
32378     try {
32379       result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
32380     } CALL_CATCH_EXCEPTION(0);
32381   }
32382
32383   jresult = (unsigned long)result;
32384   return jresult;
32385 }
32386
32387
32388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Connect(void * jarg1, void * jarg2) {
32389   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
32390   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
32391
32392   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
32393   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
32394   {
32395     try {
32396       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
32397     } CALL_CATCH_EXCEPTION();
32398   }
32399
32400 }
32401
32402
32403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
32404   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
32405   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
32406
32407   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
32408   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
32409   {
32410     try {
32411       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
32412     } CALL_CATCH_EXCEPTION();
32413   }
32414
32415 }
32416
32417
32418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Emit(void * jarg1, void * jarg2) {
32419   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
32420   Dali::KeyEvent *arg2 = 0 ;
32421
32422   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
32423   arg2 = (Dali::KeyEvent *)jarg2;
32424   if (!arg2) {
32425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32426     return ;
32427   }
32428   {
32429     try {
32430       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*arg2);
32431     } CALL_CATCH_EXCEPTION();
32432   }
32433
32434 }
32435
32436
32437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyEventSignal() {
32438   void * jresult ;
32439   Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ;
32440
32441   {
32442     try {
32443       result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >();
32444     } CALL_CATCH_EXCEPTION(0);
32445   }
32446
32447   jresult = (void *)result;
32448   return jresult;
32449 }
32450
32451
32452 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyEventSignal(void * jarg1) {
32453   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
32454
32455   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
32456   {
32457     try {
32458       delete arg1;
32459     } CALL_CATCH_EXCEPTION();
32460   }
32461
32462 }
32463
32464
32465 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TouchSignal_Empty(void * jarg1) {
32466   unsigned int jresult ;
32467   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
32468   bool result;
32469
32470   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
32471   {
32472     try {
32473       result = (bool)Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::TouchEvent const &) > const *)arg1);
32474     } CALL_CATCH_EXCEPTION(0);
32475   }
32476
32477   jresult = result;
32478   return jresult;
32479 }
32480
32481
32482 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchSignal_GetConnectionCount(void * jarg1) {
32483   unsigned long jresult ;
32484   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
32485   std::size_t result;
32486
32487   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
32488   {
32489     try {
32490       result = Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::TouchEvent const &) > const *)arg1);
32491     } CALL_CATCH_EXCEPTION(0);
32492   }
32493
32494   jresult = (unsigned long)result;
32495   return jresult;
32496 }
32497
32498
32499 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Connect(void * jarg1, void * jarg2) {
32500   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
32501   void (*arg2)(Dali::TouchEvent const &) = (void (*)(Dali::TouchEvent const &)) 0 ;
32502
32503   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
32504   arg2 = (void (*)(Dali::TouchEvent const &))jarg2;
32505   {
32506     try {
32507       Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
32508     } CALL_CATCH_EXCEPTION();
32509   }
32510
32511 }
32512
32513
32514 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Disconnect(void * jarg1, void * jarg2) {
32515   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
32516   void (*arg2)(Dali::TouchEvent const &) = (void (*)(Dali::TouchEvent const &)) 0 ;
32517
32518   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
32519   arg2 = (void (*)(Dali::TouchEvent const &))jarg2;
32520   {
32521     try {
32522       Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
32523     } CALL_CATCH_EXCEPTION();
32524   }
32525
32526 }
32527
32528
32529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Emit(void * jarg1, void * jarg2) {
32530   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
32531   Dali::TouchEvent *arg2 = 0 ;
32532
32533   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
32534   arg2 = (Dali::TouchEvent *)jarg2;
32535   if (!arg2) {
32536     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
32537     return ;
32538   }
32539   {
32540     try {
32541       Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::TouchEvent const &)*arg2);
32542     } CALL_CATCH_EXCEPTION();
32543   }
32544
32545 }
32546
32547
32548 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchSignal() {
32549   void * jresult ;
32550   Dali::Signal< void (Dali::TouchEvent const &) > *result = 0 ;
32551
32552   {
32553     try {
32554       result = (Dali::Signal< void (Dali::TouchEvent const &) > *)new Dali::Signal< void (Dali::TouchEvent const &) >();
32555     } CALL_CATCH_EXCEPTION(0);
32556   }
32557
32558   jresult = (void *)result;
32559   return jresult;
32560 }
32561
32562
32563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchSignal(void * jarg1) {
32564   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
32565
32566   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
32567   {
32568     try {
32569       delete arg1;
32570     } CALL_CATCH_EXCEPTION();
32571   }
32572
32573 }
32574
32575
32576 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StageWheelSignal_Empty(void * jarg1) {
32577   unsigned int jresult ;
32578   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
32579   bool result;
32580
32581   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
32582   {
32583     try {
32584       result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
32585     } CALL_CATCH_EXCEPTION(0);
32586   }
32587
32588   jresult = result;
32589   return jresult;
32590 }
32591
32592
32593 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StageWheelSignal_GetConnectionCount(void * jarg1) {
32594   unsigned long jresult ;
32595   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
32596   std::size_t result;
32597
32598   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
32599   {
32600     try {
32601       result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
32602     } CALL_CATCH_EXCEPTION(0);
32603   }
32604
32605   jresult = (unsigned long)result;
32606   return jresult;
32607 }
32608
32609
32610 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Connect(void * jarg1, void * jarg2) {
32611   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
32612   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
32613
32614   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
32615   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
32616   {
32617     try {
32618       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
32619     } CALL_CATCH_EXCEPTION();
32620   }
32621
32622 }
32623
32624
32625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Disconnect(void * jarg1, void * jarg2) {
32626   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
32627   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
32628
32629   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
32630   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
32631   {
32632     try {
32633       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
32634     } CALL_CATCH_EXCEPTION();
32635   }
32636
32637 }
32638
32639
32640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Emit(void * jarg1, void * jarg2) {
32641   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
32642   Dali::WheelEvent *arg2 = 0 ;
32643
32644   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
32645   arg2 = (Dali::WheelEvent *)jarg2;
32646   if (!arg2) {
32647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
32648     return ;
32649   }
32650   {
32651     try {
32652       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2);
32653     } CALL_CATCH_EXCEPTION();
32654   }
32655
32656 }
32657
32658
32659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StageWheelSignal() {
32660   void * jresult ;
32661   Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ;
32662
32663   {
32664     try {
32665       result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >();
32666     } CALL_CATCH_EXCEPTION(0);
32667   }
32668
32669   jresult = (void *)result;
32670   return jresult;
32671 }
32672
32673
32674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StageWheelSignal(void * jarg1) {
32675   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
32676
32677   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
32678   {
32679     try {
32680       delete arg1;
32681     } CALL_CATCH_EXCEPTION();
32682   }
32683
32684 }
32685
32686
32687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_0() {
32688   void * jresult ;
32689   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
32690
32691   {
32692     try {
32693       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >();
32694     } CALL_CATCH_EXCEPTION(0);
32695   }
32696
32697   jresult = (void *)result;
32698   return jresult;
32699 }
32700
32701
32702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) {
32703   void * jresult ;
32704   Dali::Radian arg1 ;
32705   Dali::Radian arg2 ;
32706   Dali::Radian *argp1 ;
32707   Dali::Radian *argp2 ;
32708   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
32709
32710   argp1 = (Dali::Radian *)jarg1;
32711   if (!argp1) {
32712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
32713     return 0;
32714   }
32715   arg1 = *argp1;
32716   argp2 = (Dali::Radian *)jarg2;
32717   if (!argp2) {
32718     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
32719     return 0;
32720   }
32721   arg2 = *argp2;
32722   {
32723     try {
32724       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2);
32725     } CALL_CATCH_EXCEPTION(0);
32726   }
32727
32728   jresult = (void *)result;
32729   return jresult;
32730 }
32731
32732
32733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_2(void * jarg1) {
32734   void * jresult ;
32735   std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ;
32736   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
32737
32738   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
32739   if (!arg1) {
32740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0);
32741     return 0;
32742   }
32743   {
32744     try {
32745       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > const &)*arg1);
32746     } CALL_CATCH_EXCEPTION(0);
32747   }
32748
32749   jresult = (void *)result;
32750   return jresult;
32751 }
32752
32753
32754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_set(void * jarg1, void * jarg2) {
32755   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
32756   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
32757
32758   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
32759   arg2 = (Dali::Radian *)jarg2;
32760   if (arg1) (arg1)->first = *arg2;
32761 }
32762
32763
32764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_get(void * jarg1) {
32765   void * jresult ;
32766   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
32767   Dali::Radian *result = 0 ;
32768
32769   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
32770   result = (Dali::Radian *)& ((arg1)->first);
32771   jresult = (void *)result;
32772   return jresult;
32773 }
32774
32775
32776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_set(void * jarg1, void * jarg2) {
32777   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
32778   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
32779
32780   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
32781   arg2 = (Dali::Radian *)jarg2;
32782   if (arg1) (arg1)->second = *arg2;
32783 }
32784
32785
32786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_get(void * jarg1) {
32787   void * jresult ;
32788   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
32789   Dali::Radian *result = 0 ;
32790
32791   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
32792   result = (Dali::Radian *)& ((arg1)->second);
32793   jresult = (void *)result;
32794   return jresult;
32795 }
32796
32797
32798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleThresholdPair(void * jarg1) {
32799   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
32800
32801   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
32802   {
32803     try {
32804       delete arg1;
32805     } CALL_CATCH_EXCEPTION();
32806   }
32807
32808 }
32809
32810
32811 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Empty(void * jarg1) {
32812   unsigned int jresult ;
32813   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
32814   bool result;
32815
32816   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
32817   {
32818     try {
32819       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);
32820     } CALL_CATCH_EXCEPTION(0);
32821   }
32822
32823   jresult = result;
32824   return jresult;
32825 }
32826
32827
32828 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) {
32829   unsigned long jresult ;
32830   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
32831   std::size_t result;
32832
32833   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
32834   {
32835     try {
32836       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);
32837     } CALL_CATCH_EXCEPTION(0);
32838   }
32839
32840   jresult = (unsigned long)result;
32841   return jresult;
32842 }
32843
32844
32845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
32846   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
32847   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
32848
32849   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
32850   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
32851   {
32852     try {
32853       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
32854     } CALL_CATCH_EXCEPTION();
32855   }
32856
32857 }
32858
32859
32860 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
32861   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
32862   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
32863
32864   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
32865   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
32866   {
32867     try {
32868       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
32869     } CALL_CATCH_EXCEPTION();
32870   }
32871
32872 }
32873
32874
32875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
32876   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
32877   Dali::Actor arg2 ;
32878   Dali::PanGesture *arg3 = 0 ;
32879   Dali::Actor *argp2 ;
32880
32881   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
32882   argp2 = (Dali::Actor *)jarg2;
32883   if (!argp2) {
32884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32885     return ;
32886   }
32887   arg2 = *argp2;
32888   arg3 = (Dali::PanGesture *)jarg3;
32889   if (!arg3) {
32890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
32891     return ;
32892   }
32893   {
32894     try {
32895       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*arg3);
32896     } CALL_CATCH_EXCEPTION();
32897   }
32898
32899 }
32900
32901
32902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetectedSignal() {
32903   void * jresult ;
32904   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ;
32905
32906   {
32907     try {
32908       result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >();
32909     } CALL_CATCH_EXCEPTION(0);
32910   }
32911
32912   jresult = (void *)result;
32913   return jresult;
32914 }
32915
32916
32917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetectedSignal(void * jarg1) {
32918   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
32919
32920   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
32921   {
32922     try {
32923       delete arg1;
32924     } CALL_CATCH_EXCEPTION();
32925   }
32926
32927 }
32928
32929
32930 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Empty(void * jarg1) {
32931   unsigned int jresult ;
32932   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
32933   bool result;
32934
32935   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
32936   {
32937     try {
32938       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);
32939     } CALL_CATCH_EXCEPTION(0);
32940   }
32941
32942   jresult = result;
32943   return jresult;
32944 }
32945
32946
32947 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) {
32948   unsigned long jresult ;
32949   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
32950   std::size_t result;
32951
32952   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
32953   {
32954     try {
32955       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);
32956     } CALL_CATCH_EXCEPTION(0);
32957   }
32958
32959   jresult = (unsigned long)result;
32960   return jresult;
32961 }
32962
32963
32964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
32965   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
32966   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
32967
32968   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
32969   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
32970   {
32971     try {
32972       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
32973     } CALL_CATCH_EXCEPTION();
32974   }
32975
32976 }
32977
32978
32979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
32980   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
32981   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
32982
32983   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
32984   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
32985   {
32986     try {
32987       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
32988     } CALL_CATCH_EXCEPTION();
32989   }
32990
32991 }
32992
32993
32994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
32995   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
32996   Dali::Actor arg2 ;
32997   Dali::PinchGesture *arg3 = 0 ;
32998   Dali::Actor *argp2 ;
32999
33000   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
33001   argp2 = (Dali::Actor *)jarg2;
33002   if (!argp2) {
33003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33004     return ;
33005   }
33006   arg2 = *argp2;
33007   arg3 = (Dali::PinchGesture *)jarg3;
33008   if (!arg3) {
33009     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
33010     return ;
33011   }
33012   {
33013     try {
33014       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3);
33015     } CALL_CATCH_EXCEPTION();
33016   }
33017
33018 }
33019
33020
33021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetectedSignal() {
33022   void * jresult ;
33023   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ;
33024
33025   {
33026     try {
33027       result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >();
33028     } CALL_CATCH_EXCEPTION(0);
33029   }
33030
33031   jresult = (void *)result;
33032   return jresult;
33033 }
33034
33035
33036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetectedSignal(void * jarg1) {
33037   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
33038
33039   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
33040   {
33041     try {
33042       delete arg1;
33043     } CALL_CATCH_EXCEPTION();
33044   }
33045
33046 }
33047
33048
33049 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Empty(void * jarg1) {
33050   unsigned int jresult ;
33051   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
33052   bool result;
33053
33054   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
33055   {
33056     try {
33057       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);
33058     } CALL_CATCH_EXCEPTION(0);
33059   }
33060
33061   jresult = result;
33062   return jresult;
33063 }
33064
33065
33066 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) {
33067   unsigned long jresult ;
33068   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
33069   std::size_t result;
33070
33071   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
33072   {
33073     try {
33074       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);
33075     } CALL_CATCH_EXCEPTION(0);
33076   }
33077
33078   jresult = (unsigned long)result;
33079   return jresult;
33080 }
33081
33082
33083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
33084   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
33085   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
33086
33087   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
33088   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
33089   {
33090     try {
33091       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
33092     } CALL_CATCH_EXCEPTION();
33093   }
33094
33095 }
33096
33097
33098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
33099   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
33100   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
33101
33102   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
33103   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
33104   {
33105     try {
33106       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
33107     } CALL_CATCH_EXCEPTION();
33108   }
33109
33110 }
33111
33112
33113 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
33114   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
33115   Dali::Actor arg2 ;
33116   Dali::TapGesture *arg3 = 0 ;
33117   Dali::Actor *argp2 ;
33118
33119   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
33120   argp2 = (Dali::Actor *)jarg2;
33121   if (!argp2) {
33122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33123     return ;
33124   }
33125   arg2 = *argp2;
33126   arg3 = (Dali::TapGesture *)jarg3;
33127   if (!arg3) {
33128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
33129     return ;
33130   }
33131   {
33132     try {
33133       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3);
33134     } CALL_CATCH_EXCEPTION();
33135   }
33136
33137 }
33138
33139
33140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetectedSignal() {
33141   void * jresult ;
33142   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ;
33143
33144   {
33145     try {
33146       result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >();
33147     } CALL_CATCH_EXCEPTION(0);
33148   }
33149
33150   jresult = (void *)result;
33151   return jresult;
33152 }
33153
33154
33155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetectedSignal(void * jarg1) {
33156   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
33157
33158   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
33159   {
33160     try {
33161       delete arg1;
33162     } CALL_CATCH_EXCEPTION();
33163   }
33164
33165 }
33166
33167
33168 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionChangedSignal_Empty(void * jarg1) {
33169   unsigned int jresult ;
33170   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
33171   bool result = false;
33172
33173   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
33174   {
33175     try {
33176       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);
33177     } CALL_CATCH_EXCEPTION(0);
33178   }
33179   jresult = result;
33180   return jresult;
33181 }
33182
33183 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_GetConnectionCount(void * jarg1) {
33184   unsigned long jresult ;
33185   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
33186   std::size_t result = 0;
33187
33188   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
33189   {
33190     try {
33191       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);
33192     }CALL_CATCH_EXCEPTION(0);
33193   }
33194   jresult = (unsigned long)result;
33195   return jresult;
33196 }
33197
33198 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Connect(void * jarg1, void * jarg2) {
33199   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
33200   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
33201
33202   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
33203   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
33204   {
33205     try {
33206       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Connect(arg1,arg2);
33207     } CALL_CATCH_EXCEPTION();
33208   }
33209 }
33210
33211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Disconnect(void * jarg1, void * jarg2) {
33212   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
33213   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
33214
33215   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
33216   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
33217   {
33218     try {
33219       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Disconnect(arg1,arg2);
33220     } CALL_CATCH_EXCEPTION();
33221   }
33222 }
33223
33224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Emit(void * jarg1, void * jarg2, int jarg4) {
33225   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
33226   Dali::Actor arg2 ;
33227   //bool arg3 ;
33228   Dali::LayoutDirection::Type arg4 ;
33229   Dali::Actor *argp2 ;
33230
33231   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
33232   argp2 = (Dali::Actor *)jarg2;
33233   if (!argp2) {
33234     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33235     return ;
33236   }
33237   arg2 = *argp2;
33238   //arg3 = jarg3 ? true : false;
33239   arg4 = (Dali::LayoutDirection::Type)jarg4;
33240   {
33241     try {
33242       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Emit(arg1,arg2,arg4);
33243     } CALL_CATCH_EXCEPTION();
33244   }
33245 }
33246
33247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewLayoutDirectionSignal() {
33248   void * jresult ;
33249   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *result = 0 ;
33250
33251   {
33252     try {
33253       result = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)new Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) >();
33254     } CALL_CATCH_EXCEPTION(0);
33255   }
33256   jresult = (void *)result;
33257   return jresult;
33258 }
33259
33260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewLayoutDirectionSignal(void * jarg1) {
33261   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
33262
33263   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
33264   {
33265     try {
33266       delete arg1;
33267     } CALL_CATCH_EXCEPTION();
33268   }
33269 }
33270
33271
33272 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_iewVisibilityChangedSignal_Empty(void * jarg1) {
33273   unsigned int jresult ;
33274   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
33275   bool result = false;
33276
33277   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
33278   {
33279     try {
33280           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);
33281     } CALL_CATCH_EXCEPTION(0);
33282   }
33283   jresult = result;
33284   return jresult;
33285 }
33286
33287
33288 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_GetConnectionCount(void * jarg1) {
33289   unsigned long jresult ;
33290   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
33291   std::size_t result;
33292
33293   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
33294   {
33295     try {
33296       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);
33297     } CALL_CATCH_EXCEPTION(0);
33298   }
33299
33300   jresult = (unsigned long)result;
33301   return jresult;
33302 }
33303
33304
33305 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Connect(void * jarg1, void * jarg2) {
33306   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
33307   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
33308
33309   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
33310   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
33311   {
33312     try {
33313       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(arg1,arg2);
33314     } CALL_CATCH_EXCEPTION();
33315   }
33316
33317 }
33318
33319
33320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Disconnect(void * jarg1, void * jarg2) {
33321   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
33322   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
33323
33324   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
33325   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
33326   {
33327     try {
33328       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(arg1,arg2);
33329     } CALL_CATCH_EXCEPTION();
33330   }
33331
33332 }
33333
33334
33335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, int jarg4) {
33336   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
33337   Dali::Actor arg2 ;
33338   bool arg3 ;
33339   Dali::DevelActor::VisibilityChange::Type arg4 ;
33340   Dali::Actor *argp2 ;
33341
33342   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
33343   argp2 = (Dali::Actor *)jarg2;
33344   if (!argp2) {
33345     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33346     return ;
33347   }
33348   arg2 = *argp2;
33349   arg3 = jarg3 ? true : false;
33350   arg4 = (Dali::DevelActor::VisibilityChange::Type)jarg4;
33351   {
33352     try {
33353       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(arg1,arg2,arg3,arg4);
33354     } CALL_CATCH_EXCEPTION();
33355   }
33356
33357 }
33358
33359
33360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewVisibilityChangedSignal() {
33361   void * jresult ;
33362   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *result = 0 ;
33363
33364   {
33365     try {
33366       result = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)new Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) >();
33367     } CALL_CATCH_EXCEPTION(0);
33368   }
33369
33370   jresult = (void *)result;
33371   return jresult;
33372 }
33373
33374
33375 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewVisibilityChangedSignal(void * jarg1) {
33376   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
33377
33378   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
33379   {
33380     try {
33381       delete arg1;
33382     } CALL_CATCH_EXCEPTION();
33383   }
33384
33385 }
33386
33387
33388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_0() {
33389   void * jresult ;
33390   Dali::Timer *result = 0 ;
33391
33392   {
33393     try {
33394       result = (Dali::Timer *)new Dali::Timer();
33395     } CALL_CATCH_EXCEPTION(0);
33396   }
33397
33398   jresult = (void *)result;
33399   return jresult;
33400 }
33401
33402
33403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_New(unsigned int jarg1) {
33404   void * jresult ;
33405   unsigned int arg1 ;
33406   Dali::Timer result;
33407
33408   arg1 = (unsigned int)jarg1;
33409   {
33410     try {
33411       result = Dali::Timer::New(arg1);
33412     } CALL_CATCH_EXCEPTION(0);
33413   }
33414
33415   jresult = new Dali::Timer((const Dali::Timer &)result);
33416   return jresult;
33417 }
33418
33419
33420 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_1(void * jarg1) {
33421   void * jresult ;
33422   Dali::Timer *arg1 = 0 ;
33423   Dali::Timer *result = 0 ;
33424
33425   arg1 = (Dali::Timer *)jarg1;
33426   if (!arg1) {
33427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
33428     return 0;
33429   }
33430   {
33431     try {
33432       result = (Dali::Timer *)new Dali::Timer((Dali::Timer const &)*arg1);
33433     } CALL_CATCH_EXCEPTION(0);
33434   }
33435
33436   jresult = (void *)result;
33437   return jresult;
33438 }
33439
33440
33441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_Assign(void * jarg1, void * jarg2) {
33442   void * jresult ;
33443   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
33444   Dali::Timer *arg2 = 0 ;
33445   Dali::Timer *result = 0 ;
33446
33447   arg1 = (Dali::Timer *)jarg1;
33448   arg2 = (Dali::Timer *)jarg2;
33449   if (!arg2) {
33450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
33451     return 0;
33452   }
33453   {
33454     try {
33455       result = (Dali::Timer *) &(arg1)->operator =((Dali::Timer const &)*arg2);
33456     } CALL_CATCH_EXCEPTION(0);
33457   }
33458
33459   jresult = (void *)result;
33460   return jresult;
33461 }
33462
33463
33464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Timer(void * jarg1) {
33465   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
33466
33467   arg1 = (Dali::Timer *)jarg1;
33468   {
33469     try {
33470       delete arg1;
33471     } CALL_CATCH_EXCEPTION();
33472   }
33473
33474 }
33475
33476
33477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_DownCast(void * jarg1) {
33478   void * jresult ;
33479   Dali::BaseHandle arg1 ;
33480   Dali::BaseHandle *argp1 ;
33481   Dali::Timer result;
33482
33483   argp1 = (Dali::BaseHandle *)jarg1;
33484   if (!argp1) {
33485     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
33486     return 0;
33487   }
33488   arg1 = *argp1;
33489   {
33490     try {
33491       result = Dali::Timer::DownCast(arg1);
33492     } CALL_CATCH_EXCEPTION(0);
33493   }
33494
33495   jresult = new Dali::Timer((const Dali::Timer &)result);
33496   return jresult;
33497 }
33498
33499
33500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Start(void * jarg1) {
33501   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
33502
33503   arg1 = (Dali::Timer *)jarg1;
33504   {
33505     try {
33506       (arg1)->Start();
33507     } CALL_CATCH_EXCEPTION();
33508   }
33509
33510 }
33511
33512
33513 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Stop(void * jarg1) {
33514   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
33515
33516   arg1 = (Dali::Timer *)jarg1;
33517   {
33518     try {
33519       (arg1)->Stop();
33520     } CALL_CATCH_EXCEPTION();
33521   }
33522
33523 }
33524
33525
33526 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_SetInterval(void * jarg1, unsigned int jarg2) {
33527   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
33528   unsigned int arg2 ;
33529
33530   arg1 = (Dali::Timer *)jarg1;
33531   arg2 = (unsigned int)jarg2;
33532   {
33533     try {
33534       (arg1)->SetInterval(arg2);
33535     } CALL_CATCH_EXCEPTION();
33536   }
33537
33538 }
33539
33540
33541 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_GetInterval(void * jarg1) {
33542   unsigned int jresult ;
33543   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
33544   unsigned int result;
33545
33546   arg1 = (Dali::Timer *)jarg1;
33547   {
33548     try {
33549       result = (unsigned int)((Dali::Timer const *)arg1)->GetInterval();
33550     } CALL_CATCH_EXCEPTION(0);
33551   }
33552
33553   jresult = result;
33554   return jresult;
33555 }
33556
33557
33558 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_IsRunning(void * jarg1) {
33559   unsigned int jresult ;
33560   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
33561   bool result;
33562
33563   arg1 = (Dali::Timer *)jarg1;
33564   {
33565     try {
33566       result = (bool)((Dali::Timer const *)arg1)->IsRunning();
33567     } CALL_CATCH_EXCEPTION(0);
33568   }
33569
33570   jresult = result;
33571   return jresult;
33572 }
33573
33574
33575 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_TickSignal(void * jarg1) {
33576   void * jresult ;
33577   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
33578   Dali::Timer::TimerSignalType *result = 0 ;
33579
33580   arg1 = (Dali::Timer *)jarg1;
33581   {
33582     try {
33583       result = (Dali::Timer::TimerSignalType *) &(arg1)->TickSignal();
33584     } CALL_CATCH_EXCEPTION(0);
33585   }
33586
33587   jresult = (void *)result;
33588   return jresult;
33589 }
33590
33591
33592 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Empty(void * jarg1) {
33593   unsigned int jresult ;
33594   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
33595   bool result;
33596
33597   arg1 = (Dali::Signal< bool () > *)jarg1;
33598   {
33599     try {
33600       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Empty((Dali::Signal< bool () > const *)arg1);
33601     } CALL_CATCH_EXCEPTION(0);
33602   }
33603
33604   jresult = result;
33605   return jresult;
33606 }
33607
33608
33609 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TimerSignalType_GetConnectionCount(void * jarg1) {
33610   unsigned long jresult ;
33611   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
33612   std::size_t result;
33613
33614   arg1 = (Dali::Signal< bool () > *)jarg1;
33615   {
33616     try {
33617       result = Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount((Dali::Signal< bool () > const *)arg1);
33618     } CALL_CATCH_EXCEPTION(0);
33619   }
33620
33621   jresult = (unsigned long)result;
33622   return jresult;
33623 }
33624
33625
33626 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect(void * jarg1, void * jarg2) {
33627   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
33628   bool (*arg2)() = (bool (*)()) 0 ;
33629
33630   arg1 = (Dali::Signal< bool () > *)jarg1;
33631   arg2 = (bool (*)())jarg2;
33632   {
33633     try {
33634       Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(arg1,arg2);
33635     } CALL_CATCH_EXCEPTION();
33636   }
33637
33638 }
33639
33640
33641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Disconnect(void * jarg1, void * jarg2) {
33642   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
33643   bool (*arg2)() = (bool (*)()) 0 ;
33644
33645   arg1 = (Dali::Signal< bool () > *)jarg1;
33646   arg2 = (bool (*)())jarg2;
33647   {
33648     try {
33649       Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(arg1,arg2);
33650     } CALL_CATCH_EXCEPTION();
33651   }
33652
33653 }
33654
33655
33656 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Emit(void * jarg1) {
33657   unsigned int jresult ;
33658   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
33659   bool result;
33660
33661   arg1 = (Dali::Signal< bool () > *)jarg1;
33662   {
33663     try {
33664       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(arg1);
33665     } CALL_CATCH_EXCEPTION(0);
33666   }
33667
33668   jresult = result;
33669   return jresult;
33670 }
33671
33672
33673 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimerSignalType() {
33674   void * jresult ;
33675   Dali::Signal< bool () > *result = 0 ;
33676
33677   {
33678     try {
33679       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
33680     } CALL_CATCH_EXCEPTION(0);
33681   }
33682
33683   jresult = (void *)result;
33684   return jresult;
33685 }
33686
33687
33688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimerSignalType(void * jarg1) {
33689   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
33690
33691   arg1 = (Dali::Signal< bool () > *)jarg1;
33692   {
33693     try {
33694       delete arg1;
33695     } CALL_CATCH_EXCEPTION();
33696   }
33697
33698 }
33699
33700
33701 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() {
33702   int jresult ;
33703   int result;
33704
33705   {
33706     try {
33707       result = (int)Dali::Toolkit::Visual::Property::TYPE;
33708     } CALL_CATCH_EXCEPTION(0);
33709   }
33710
33711   jresult = (int)result;
33712   return jresult;
33713 }
33714
33715
33716 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_SHADER_get() {
33717   int jresult ;
33718   int result;
33719
33720   {
33721     try {
33722       result = (int)Dali::Toolkit::Visual::Property::SHADER;
33723     } CALL_CATCH_EXCEPTION(0);
33724   }
33725
33726   jresult = (int)result;
33727   return jresult;
33728 }
33729
33730
33731 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_VERTEX_get() {
33732   int jresult ;
33733   int result;
33734
33735   {
33736     try {
33737       result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
33738     } CALL_CATCH_EXCEPTION(0);
33739   }
33740
33741   jresult = (int)result;
33742   return jresult;
33743 }
33744
33745
33746 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_FRAGMENT_get() {
33747   int jresult ;
33748   int result;
33749
33750   {
33751     try {
33752       result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER;
33753     } CALL_CATCH_EXCEPTION(0);
33754   }
33755
33756   jresult = (int)result;
33757   return jresult;
33758 }
33759
33760
33761 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_X_get() {
33762   int jresult ;
33763   int result;
33764
33765   {
33766     try {
33767       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X;
33768     } CALL_CATCH_EXCEPTION(0);
33769   }
33770
33771   jresult = (int)result;
33772   return jresult;
33773 }
33774
33775
33776 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_Y_get() {
33777   int jresult ;
33778   int result;
33779
33780   {
33781     try {
33782       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y;
33783     } CALL_CATCH_EXCEPTION(0);
33784   }
33785
33786   jresult = (int)result;
33787   return jresult;
33788 }
33789
33790
33791 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_HINTS_get() {
33792   int jresult ;
33793   int result;
33794
33795   {
33796     try {
33797       result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS;
33798     } CALL_CATCH_EXCEPTION(0);
33799   }
33800
33801   jresult = (int)result;
33802   return jresult;
33803 }
33804
33805
33806 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_COLOR_get() {
33807   int jresult ;
33808   int result;
33809
33810   {
33811     try {
33812       result = (int)Dali::Toolkit::BorderVisual::Property::COLOR;
33813     } CALL_CATCH_EXCEPTION(0);
33814   }
33815
33816   jresult = (int)result;
33817   return jresult;
33818 }
33819
33820
33821 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_SIZE_get() {
33822   int jresult ;
33823   int result;
33824
33825   {
33826     try {
33827       result = (int)Dali::Toolkit::BorderVisual::Property::SIZE;
33828     } CALL_CATCH_EXCEPTION(0);
33829   }
33830
33831   jresult = (int)result;
33832   return jresult;
33833 }
33834
33835
33836 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_ANTI_ALIASING_get() {
33837   int jresult ;
33838   int result;
33839
33840   {
33841     try {
33842       result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING;
33843     } CALL_CATCH_EXCEPTION(0);
33844   }
33845
33846   jresult = (int)result;
33847   return jresult;
33848 }
33849
33850
33851 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_COLOR_VISUAL_MIX_COLOR_get() {
33852   int jresult ;
33853   int result;
33854
33855   {
33856     try {
33857       result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR;
33858     } CALL_CATCH_EXCEPTION(0);
33859   }
33860
33861   jresult = (int)result;
33862   return jresult;
33863 }
33864
33865
33866 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_START_POSITION_get() {
33867   int jresult ;
33868   int result;
33869
33870   {
33871     try {
33872       result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION;
33873     } CALL_CATCH_EXCEPTION(0);
33874   }
33875
33876   jresult = (int)result;
33877   return jresult;
33878 }
33879
33880
33881 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_END_POSITION_get() {
33882   int jresult ;
33883   int result;
33884
33885   {
33886     try {
33887       result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION;
33888     } CALL_CATCH_EXCEPTION(0);
33889   }
33890
33891   jresult = (int)result;
33892   return jresult;
33893 }
33894
33895
33896 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_CENTER_get() {
33897   int jresult ;
33898   int result;
33899
33900   {
33901     try {
33902       result = (int)Dali::Toolkit::GradientVisual::Property::CENTER;
33903     } CALL_CATCH_EXCEPTION(0);
33904   }
33905
33906   jresult = (int)result;
33907   return jresult;
33908 }
33909
33910
33911 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_RADIUS_get() {
33912   int jresult ;
33913   int result;
33914
33915   {
33916     try {
33917       result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS;
33918     } CALL_CATCH_EXCEPTION(0);
33919   }
33920
33921   jresult = (int)result;
33922   return jresult;
33923 }
33924
33925
33926 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_OFFSET_get() {
33927   int jresult ;
33928   int result;
33929
33930   {
33931     try {
33932       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET;
33933     } CALL_CATCH_EXCEPTION(0);
33934   }
33935
33936   jresult = (int)result;
33937   return jresult;
33938 }
33939
33940
33941 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_COLOR_get() {
33942   int jresult ;
33943   int result;
33944
33945   {
33946     try {
33947       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR;
33948     } CALL_CATCH_EXCEPTION(0);
33949   }
33950
33951   jresult = (int)result;
33952   return jresult;
33953 }
33954
33955
33956 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_UNITS_get() {
33957   int jresult ;
33958   int result;
33959
33960   {
33961     try {
33962       result = (int)Dali::Toolkit::GradientVisual::Property::UNITS;
33963     } CALL_CATCH_EXCEPTION(0);
33964   }
33965
33966   jresult = (int)result;
33967   return jresult;
33968 }
33969
33970
33971 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_SPREAD_METHOD_get() {
33972   int jresult ;
33973   int result;
33974
33975   {
33976     try {
33977       result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD;
33978     } CALL_CATCH_EXCEPTION(0);
33979   }
33980
33981   jresult = (int)result;
33982   return jresult;
33983 }
33984
33985
33986 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_URL_get() {
33987   int jresult ;
33988   int result;
33989
33990   {
33991     try {
33992       result = (int)Dali::Toolkit::ImageVisual::Property::URL;
33993     } CALL_CATCH_EXCEPTION(0);
33994   }
33995
33996   jresult = (int)result;
33997   return jresult;
33998 }
33999
34000 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ALPHA_MASK_URL_get() {
34001   int jresult ;
34002   int result;
34003
34004   {
34005     try {
34006       result = (int)Dali::Toolkit::ImageVisual::Property::ALPHA_MASK_URL;
34007     } CALL_CATCH_EXCEPTION(0);
34008   }
34009
34010   jresult = (int)result;
34011   return jresult;
34012 }
34013
34014
34015 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BATCH_SIZE_get() {
34016   int jresult ;
34017   int result;
34018   {
34019     try
34020     {
34021       result = (int)Dali::Toolkit::ImageVisual::Property::BATCH_SIZE;
34022     } CALL_CATCH_EXCEPTION(0);
34023   }
34024
34025   jresult = (int)result;
34026   return jresult;
34027 }
34028
34029 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CACHE_SIZE_get() {
34030   int jresult ;
34031   int result;
34032   {
34033     try
34034     {
34035       result = (int)Dali::Toolkit::ImageVisual::Property::CACHE_SIZE;
34036     } CALL_CATCH_EXCEPTION(0);
34037   }
34038
34039   jresult = (int)result;
34040   return jresult;
34041 }
34042
34043 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FRAME_DELAY_get() {
34044   int jresult ;
34045   int result;
34046   {
34047     try
34048     {
34049       result = (int)Dali::Toolkit::ImageVisual::Property::FRAME_DELAY;
34050     } CALL_CATCH_EXCEPTION(0);
34051   }
34052
34053   jresult = (int)result;
34054   return jresult;
34055 }
34056
34057 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOOP_COUNT_get() {
34058   return (int)Dali::Toolkit::DevelImageVisual::Property::LOOP_COUNT;
34059 }
34060
34061 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_MASK_CONTENT_SCALE_get() {
34062   int jresult ;
34063   int result;
34064   {
34065     try
34066     {
34067       result = (int)Dali::Toolkit::ImageVisual::Property::MASK_CONTENT_SCALE;
34068     } CALL_CATCH_EXCEPTION(0);
34069   }
34070
34071   jresult = (int)result;
34072   return jresult;
34073 }
34074
34075 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CROP_TO_MASK_get() {
34076   int jresult ;
34077   int result;
34078   {
34079     try
34080     {
34081       result = (int)Dali::Toolkit::ImageVisual::Property::CROP_TO_MASK;
34082     } CALL_CATCH_EXCEPTION(0);
34083   }
34084
34085   jresult = (int)result;
34086   return jresult;
34087 }
34088
34089 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() {
34090   int jresult ;
34091   int result;
34092
34093   {
34094     try {
34095       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE;
34096     } CALL_CATCH_EXCEPTION(0);
34097   }
34098
34099   jresult = (int)result;
34100   return jresult;
34101 }
34102
34103
34104 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SAMPLING_MODE_get() {
34105   int jresult ;
34106   int result;
34107
34108   {
34109     try {
34110       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
34111     } CALL_CATCH_EXCEPTION(0);
34112   }
34113
34114   jresult = (int)result;
34115   return jresult;
34116 }
34117
34118 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_RELEASE_POLICY_get() {
34119   int jresult ;
34120   int result;
34121   {
34122     try
34123     {
34124       result = (int)Dali::Toolkit::ImageVisual::Property::RELEASE_POLICY;
34125     } CALL_CATCH_EXCEPTION(0);
34126   }
34127
34128   jresult = (int)result;
34129   return jresult;
34130 }
34131
34132 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOAD_POLICY_get() {
34133   int jresult ;
34134   int result;
34135   {
34136     try
34137     {
34138       result = (int)Dali::Toolkit::ImageVisual::Property::LOAD_POLICY;
34139     } CALL_CATCH_EXCEPTION(0);
34140   }
34141
34142   jresult = (int)result;
34143   return jresult;
34144 }
34145
34146 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ORIENTATION_CORRECTION_get() {
34147   int jresult ;
34148   int result;
34149   {
34150     try
34151     {
34152       result = (int)Dali::Toolkit::ImageVisual::Property::ORIENTATION_CORRECTION;
34153     } CALL_CATCH_EXCEPTION(0);
34154   }
34155
34156   jresult = (int)result;
34157   return jresult;
34158 }
34159
34160
34161 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_URL_get() {
34162   int jresult ;
34163   int result;
34164   {
34165     try
34166     {
34167       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE;
34168     } CALL_CATCH_EXCEPTION(0);
34169   }
34170
34171   jresult = (int)result;
34172   return jresult;
34173 }
34174
34175 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_ALPHA_get() {
34176   int jresult ;
34177   int result;
34178   {
34179     try
34180     {
34181       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA;
34182     } CALL_CATCH_EXCEPTION(0);
34183   }
34184
34185   jresult = (int)result;
34186   return jresult;
34187 }
34188
34189
34190
34191 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() {
34192   int jresult ;
34193   int result;
34194
34195   {
34196     try {
34197       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
34198     } CALL_CATCH_EXCEPTION(0);
34199   }
34200
34201   jresult = (int)result;
34202   return jresult;
34203 }
34204
34205
34206 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
34207   int jresult ;
34208   int result;
34209
34210   {
34211     try {
34212       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
34213     } CALL_CATCH_EXCEPTION(0);
34214   }
34215
34216   jresult = (int)result;
34217   return jresult;
34218 }
34219
34220
34221 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
34222   int jresult ;
34223   int result;
34224
34225   {
34226     try {
34227       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
34228     } CALL_CATCH_EXCEPTION(0);
34229   }
34230
34231   jresult = (int)result;
34232   return jresult;
34233 }
34234
34235
34236 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() {
34237   int jresult ;
34238   int result;
34239
34240   {
34241     try {
34242       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
34243     } CALL_CATCH_EXCEPTION(0);
34244   }
34245
34246   jresult = (int)result;
34247   return jresult;
34248 }
34249
34250
34251 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() {
34252   int jresult ;
34253   int result;
34254
34255   {
34256     try {
34257       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
34258     } CALL_CATCH_EXCEPTION(0);
34259   }
34260
34261   jresult = (int)result;
34262   return jresult;
34263 }
34264
34265
34266 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() {
34267   int jresult ;
34268   int result;
34269
34270   {
34271     try {
34272       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
34273     } CALL_CATCH_EXCEPTION(0);
34274   }
34275
34276   jresult = (int)result;
34277   return jresult;
34278 }
34279
34280
34281 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get() {
34282   int jresult ;
34283   int result;
34284
34285   {
34286     try {
34287       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
34288     } CALL_CATCH_EXCEPTION(0);
34289   }
34290
34291   jresult = (int)result;
34292   return jresult;
34293 }
34294
34295 SWIGEXPORT int SWIGSTDCALL CSharp_Image_Visual_BORDER_get() {
34296   int jresult ;
34297   int result;
34298
34299   {
34300     try {
34301       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER;
34302     } CALL_CATCH_EXCEPTION(0);
34303   }
34304
34305   jresult = (int)result;
34306   return jresult;
34307 }
34308
34309 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() {
34310   int jresult ;
34311   int result;
34312
34313   {
34314     try {
34315       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
34316     } CALL_CATCH_EXCEPTION(0);
34317   }
34318
34319   jresult = (int)result;
34320   return jresult;
34321 }
34322
34323
34324 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() {
34325   int jresult ;
34326   int result;
34327
34328   {
34329     try {
34330       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
34331     } CALL_CATCH_EXCEPTION(0);
34332   }
34333
34334   jresult = (int)result;
34335   return jresult;
34336 }
34337
34338
34339 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() {
34340   int jresult ;
34341   int result;
34342
34343   {
34344     try {
34345       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
34346     } CALL_CATCH_EXCEPTION(0);
34347   }
34348
34349   jresult = (int)result;
34350   return jresult;
34351 }
34352
34353
34354 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() {
34355   int jresult ;
34356   int result;
34357
34358   {
34359     try {
34360       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
34361     } CALL_CATCH_EXCEPTION(0);
34362   }
34363
34364   jresult = (int)result;
34365   return jresult;
34366 }
34367
34368
34369 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() {
34370   int jresult ;
34371   int result;
34372
34373   {
34374     try {
34375       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
34376     } CALL_CATCH_EXCEPTION(0);
34377   }
34378
34379   jresult = (int)result;
34380   return jresult;
34381 }
34382
34383
34384 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() {
34385   int jresult ;
34386   int result;
34387
34388   {
34389     try {
34390       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
34391     } CALL_CATCH_EXCEPTION(0);
34392   }
34393
34394   jresult = (int)result;
34395   return jresult;
34396 }
34397
34398
34399 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() {
34400   int jresult ;
34401   int result;
34402
34403   {
34404     try {
34405       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
34406     } CALL_CATCH_EXCEPTION(0);
34407   }
34408
34409   jresult = (int)result;
34410   return jresult;
34411 }
34412
34413
34414 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() {
34415   int jresult ;
34416   int result;
34417
34418   {
34419     try {
34420       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
34421     } CALL_CATCH_EXCEPTION(0);
34422   }
34423
34424   jresult = (int)result;
34425   return jresult;
34426 }
34427
34428
34429 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
34430   int jresult ;
34431   int result;
34432
34433   {
34434     try {
34435       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
34436     } CALL_CATCH_EXCEPTION(0);
34437   }
34438
34439   jresult = (int)result;
34440   return jresult;
34441 }
34442
34443
34444 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() {
34445   int jresult ;
34446   int result;
34447
34448   {
34449     try {
34450       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
34451     } CALL_CATCH_EXCEPTION(0);
34452   }
34453
34454   jresult = (int)result;
34455   return jresult;
34456 }
34457
34458
34459 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() {
34460   int jresult ;
34461   int result;
34462
34463   {
34464     try {
34465       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
34466     } CALL_CATCH_EXCEPTION(0);
34467   }
34468
34469   jresult = (int)result;
34470   return jresult;
34471 }
34472
34473
34474 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() {
34475   int jresult ;
34476   int result;
34477
34478   {
34479     try {
34480       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
34481     } CALL_CATCH_EXCEPTION(0);
34482   }
34483
34484   jresult = (int)result;
34485   return jresult;
34486 }
34487
34488
34489 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() {
34490   int jresult ;
34491   int result;
34492
34493   {
34494     try {
34495       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
34496     } CALL_CATCH_EXCEPTION(0);
34497   }
34498
34499   jresult = (int)result;
34500   return jresult;
34501 }
34502
34503
34504 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() {
34505   int jresult ;
34506   int result;
34507
34508   {
34509     try {
34510       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
34511     } CALL_CATCH_EXCEPTION(0);
34512   }
34513
34514   jresult = (int)result;
34515   return jresult;
34516 }
34517
34518
34519 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() {
34520   int jresult ;
34521   int result;
34522
34523   {
34524     try {
34525       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
34526     } CALL_CATCH_EXCEPTION(0);
34527   }
34528
34529   jresult = (int)result;
34530   return jresult;
34531 }
34532
34533
34534 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() {
34535   int jresult ;
34536   int result;
34537
34538   {
34539     try {
34540       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
34541     } CALL_CATCH_EXCEPTION(0);
34542   }
34543
34544   jresult = (int)result;
34545   return jresult;
34546 }
34547
34548
34549 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() {
34550   int jresult ;
34551   int result;
34552
34553   {
34554     try {
34555       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
34556     } CALL_CATCH_EXCEPTION(0);
34557   }
34558
34559   jresult = (int)result;
34560   return jresult;
34561 }
34562
34563
34564 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() {
34565   int jresult ;
34566   int result;
34567
34568   {
34569     try {
34570       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
34571     } CALL_CATCH_EXCEPTION(0);
34572   }
34573
34574   jresult = (int)result;
34575   return jresult;
34576 }
34577
34578
34579 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
34580   int jresult ;
34581   int result;
34582
34583   {
34584     try {
34585       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
34586     } CALL_CATCH_EXCEPTION(0);
34587   }
34588
34589   jresult = (int)result;
34590   return jresult;
34591 }
34592
34593
34594 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_get() {
34595   int jresult ;
34596   int result;
34597
34598   {
34599     try {
34600       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
34601     } CALL_CATCH_EXCEPTION(0);
34602   }
34603
34604   jresult = (int)result;
34605   return jresult;
34606 }
34607
34608
34609 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() {
34610   int jresult ;
34611   int result;
34612
34613   {
34614     try {
34615       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
34616     } CALL_CATCH_EXCEPTION(0);
34617   }
34618
34619   jresult = (int)result;
34620   return jresult;
34621 }
34622
34623
34624 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() {
34625   int jresult ;
34626   int result;
34627
34628   {
34629     try {
34630       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
34631     } CALL_CATCH_EXCEPTION(0);
34632   }
34633
34634   jresult = (int)result;
34635   return jresult;
34636 }
34637
34638
34639 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() {
34640   int jresult ;
34641   int result;
34642
34643   {
34644     try {
34645       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
34646     } CALL_CATCH_EXCEPTION(0);
34647   }
34648
34649   jresult = (int)result;
34650   return jresult;
34651 }
34652
34653
34654 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() {
34655   int jresult ;
34656   int result;
34657
34658   {
34659     try {
34660       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
34661     } CALL_CATCH_EXCEPTION(0);
34662   }
34663
34664   jresult = (int)result;
34665   return jresult;
34666 }
34667
34668
34669 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() {
34670   int jresult ;
34671   int result;
34672
34673   {
34674     try {
34675       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
34676     } CALL_CATCH_EXCEPTION(0);
34677   }
34678
34679   jresult = (int)result;
34680   return jresult;
34681 }
34682
34683
34684 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() {
34685   int jresult ;
34686   int result;
34687
34688   {
34689     try {
34690       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
34691     } CALL_CATCH_EXCEPTION(0);
34692   }
34693
34694   jresult = (int)result;
34695   return jresult;
34696 }
34697
34698
34699 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() {
34700   int jresult ;
34701   int result;
34702
34703   {
34704     try {
34705       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
34706     } CALL_CATCH_EXCEPTION(0);
34707   }
34708
34709   jresult = (int)result;
34710   return jresult;
34711 }
34712
34713
34714 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() {
34715   int jresult ;
34716   int result;
34717
34718   {
34719     try {
34720       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
34721     } CALL_CATCH_EXCEPTION(0);
34722   }
34723
34724   jresult = (int)result;
34725   return jresult;
34726 }
34727
34728
34729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() {
34730   void * jresult ;
34731   Dali::Toolkit::Builder *result = 0 ;
34732
34733   {
34734     try {
34735       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
34736     } CALL_CATCH_EXCEPTION(0);
34737   }
34738
34739   jresult = (void *)result;
34740   return jresult;
34741 }
34742
34743
34744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() {
34745   void * jresult ;
34746   Dali::Toolkit::Builder result;
34747
34748   {
34749     try {
34750       result = Dali::Toolkit::Builder::New();
34751     } CALL_CATCH_EXCEPTION(0);
34752   }
34753
34754   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
34755   return jresult;
34756 }
34757
34758
34759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
34760   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
34761
34762   arg1 = (Dali::Toolkit::Builder *)jarg1;
34763   {
34764     try {
34765       delete arg1;
34766     } CALL_CATCH_EXCEPTION();
34767   }
34768
34769 }
34770
34771
34772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
34773   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
34774   std::string *arg2 = 0 ;
34775   Dali::Toolkit::Builder::UIFormat arg3 ;
34776
34777   arg1 = (Dali::Toolkit::Builder *)jarg1;
34778   if (!jarg2) {
34779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
34780     return ;
34781   }
34782   std::string arg2_str(jarg2);
34783   arg2 = &arg2_str;
34784   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
34785   {
34786     try {
34787       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
34788     } CALL_CATCH_EXCEPTION();
34789   }
34790
34791
34792   //argout typemap for const std::string&
34793
34794 }
34795
34796
34797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
34798   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
34799   std::string *arg2 = 0 ;
34800
34801   arg1 = (Dali::Toolkit::Builder *)jarg1;
34802   if (!jarg2) {
34803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
34804     return ;
34805   }
34806   std::string arg2_str(jarg2);
34807   arg2 = &arg2_str;
34808   {
34809     try {
34810       (arg1)->LoadFromString((std::string const &)*arg2);
34811     } CALL_CATCH_EXCEPTION();
34812   }
34813
34814
34815   //argout typemap for const std::string&
34816
34817 }
34818
34819
34820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) {
34821   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
34822   Dali::Property::Map *arg2 = 0 ;
34823
34824   arg1 = (Dali::Toolkit::Builder *)jarg1;
34825   arg2 = (Dali::Property::Map *)jarg2;
34826   if (!arg2) {
34827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
34828     return ;
34829   }
34830   {
34831     try {
34832       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
34833     } CALL_CATCH_EXCEPTION();
34834   }
34835
34836 }
34837
34838
34839 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
34840   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
34841   std::string *arg2 = 0 ;
34842   Dali::Property::Value *arg3 = 0 ;
34843
34844   arg1 = (Dali::Toolkit::Builder *)jarg1;
34845   if (!jarg2) {
34846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
34847     return ;
34848   }
34849   std::string arg2_str(jarg2);
34850   arg2 = &arg2_str;
34851   arg3 = (Dali::Property::Value *)jarg3;
34852   if (!arg3) {
34853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
34854     return ;
34855   }
34856   {
34857     try {
34858       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
34859     } CALL_CATCH_EXCEPTION();
34860   }
34861
34862
34863   //argout typemap for const std::string&
34864
34865 }
34866
34867
34868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
34869   void * jresult ;
34870   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
34871   Dali::Property::Map *result = 0 ;
34872
34873   arg1 = (Dali::Toolkit::Builder *)jarg1;
34874   {
34875     try {
34876       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
34877     } CALL_CATCH_EXCEPTION(0);
34878   }
34879
34880   jresult = (void *)result;
34881   return jresult;
34882 }
34883
34884
34885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) {
34886   void * jresult ;
34887   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
34888   std::string *arg2 = 0 ;
34889   Dali::Property::Value *result = 0 ;
34890
34891   arg1 = (Dali::Toolkit::Builder *)jarg1;
34892   if (!jarg2) {
34893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
34894     return 0;
34895   }
34896   std::string arg2_str(jarg2);
34897   arg2 = &arg2_str;
34898   {
34899     try {
34900       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
34901     } CALL_CATCH_EXCEPTION(0);
34902   }
34903
34904   jresult = (void *)result;
34905
34906   //argout typemap for const std::string&
34907
34908   return jresult;
34909 }
34910
34911
34912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
34913   void * jresult ;
34914   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
34915   std::string *arg2 = 0 ;
34916   Dali::Animation result;
34917
34918   arg1 = (Dali::Toolkit::Builder *)jarg1;
34919   if (!jarg2) {
34920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
34921     return 0;
34922   }
34923   std::string arg2_str(jarg2);
34924   arg2 = &arg2_str;
34925   {
34926     try {
34927       result = (arg1)->CreateAnimation((std::string const &)*arg2);
34928     } CALL_CATCH_EXCEPTION(0);
34929   }
34930
34931   jresult = new Dali::Animation((const Dali::Animation &)result);
34932
34933   //argout typemap for const std::string&
34934
34935   return jresult;
34936 }
34937
34938
34939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
34940   void * jresult ;
34941   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
34942   std::string *arg2 = 0 ;
34943   Dali::Property::Map *arg3 = 0 ;
34944   Dali::Animation result;
34945
34946   arg1 = (Dali::Toolkit::Builder *)jarg1;
34947   if (!jarg2) {
34948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
34949     return 0;
34950   }
34951   std::string arg2_str(jarg2);
34952   arg2 = &arg2_str;
34953   arg3 = (Dali::Property::Map *)jarg3;
34954   if (!arg3) {
34955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
34956     return 0;
34957   }
34958   {
34959     try {
34960       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
34961     } CALL_CATCH_EXCEPTION(0);
34962   }
34963
34964   jresult = new Dali::Animation((const Dali::Animation &)result);
34965
34966   //argout typemap for const std::string&
34967
34968   return jresult;
34969 }
34970
34971
34972 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
34973   void * jresult ;
34974   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
34975   std::string *arg2 = 0 ;
34976   Dali::Actor arg3 ;
34977   Dali::Actor *argp3 ;
34978   Dali::Animation result;
34979
34980   arg1 = (Dali::Toolkit::Builder *)jarg1;
34981   if (!jarg2) {
34982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
34983     return 0;
34984   }
34985   std::string arg2_str(jarg2);
34986   arg2 = &arg2_str;
34987   argp3 = (Dali::Actor *)jarg3;
34988   if (!argp3) {
34989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
34990     return 0;
34991   }
34992   arg3 = *argp3;
34993   {
34994     try {
34995       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
34996     } CALL_CATCH_EXCEPTION(0);
34997   }
34998
34999   jresult = new Dali::Animation((const Dali::Animation &)result);
35000
35001   //argout typemap for const std::string&
35002
35003   return jresult;
35004 }
35005
35006
35007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
35008   void * jresult ;
35009   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
35010   std::string *arg2 = 0 ;
35011   Dali::Property::Map *arg3 = 0 ;
35012   Dali::Actor arg4 ;
35013   Dali::Actor *argp4 ;
35014   Dali::Animation result;
35015
35016   arg1 = (Dali::Toolkit::Builder *)jarg1;
35017   if (!jarg2) {
35018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
35019     return 0;
35020   }
35021   std::string arg2_str(jarg2);
35022   arg2 = &arg2_str;
35023   arg3 = (Dali::Property::Map *)jarg3;
35024   if (!arg3) {
35025     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
35026     return 0;
35027   }
35028   argp4 = (Dali::Actor *)jarg4;
35029   if (!argp4) {
35030     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
35031     return 0;
35032   }
35033   arg4 = *argp4;
35034   {
35035     try {
35036       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
35037     } CALL_CATCH_EXCEPTION(0);
35038   }
35039
35040   jresult = new Dali::Animation((const Dali::Animation &)result);
35041
35042   //argout typemap for const std::string&
35043
35044   return jresult;
35045 }
35046
35047
35048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
35049   void * jresult ;
35050   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
35051   std::string *arg2 = 0 ;
35052   Dali::BaseHandle result;
35053
35054   arg1 = (Dali::Toolkit::Builder *)jarg1;
35055   if (!jarg2) {
35056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
35057     return 0;
35058   }
35059   std::string arg2_str(jarg2);
35060   arg2 = &arg2_str;
35061   {
35062     try {
35063       result = (arg1)->Create((std::string const &)*arg2);
35064     } CALL_CATCH_EXCEPTION(0);
35065   }
35066
35067   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
35068
35069   //argout typemap for const std::string&
35070
35071   return jresult;
35072 }
35073
35074
35075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
35076   void * jresult ;
35077   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
35078   std::string *arg2 = 0 ;
35079   Dali::Property::Map *arg3 = 0 ;
35080   Dali::BaseHandle result;
35081
35082   arg1 = (Dali::Toolkit::Builder *)jarg1;
35083   if (!jarg2) {
35084     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
35085     return 0;
35086   }
35087   std::string arg2_str(jarg2);
35088   arg2 = &arg2_str;
35089   arg3 = (Dali::Property::Map *)jarg3;
35090   if (!arg3) {
35091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
35092     return 0;
35093   }
35094   {
35095     try {
35096       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
35097     } CALL_CATCH_EXCEPTION(0);
35098   }
35099
35100   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
35101
35102   //argout typemap for const std::string&
35103
35104   return jresult;
35105 }
35106
35107
35108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
35109   void * jresult ;
35110   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
35111   std::string *arg2 = 0 ;
35112   Dali::BaseHandle result;
35113
35114   arg1 = (Dali::Toolkit::Builder *)jarg1;
35115   if (!jarg2) {
35116     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
35117     return 0;
35118   }
35119   std::string arg2_str(jarg2);
35120   arg2 = &arg2_str;
35121   {
35122     try {
35123       result = (arg1)->CreateFromJson((std::string const &)*arg2);
35124     } CALL_CATCH_EXCEPTION(0);
35125   }
35126
35127   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
35128
35129   //argout typemap for const std::string&
35130
35131   return jresult;
35132 }
35133
35134
35135 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
35136   unsigned int jresult ;
35137   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
35138   std::string *arg2 = 0 ;
35139   Dali::Handle *arg3 = 0 ;
35140   bool result;
35141
35142   arg1 = (Dali::Toolkit::Builder *)jarg1;
35143   if (!jarg2) {
35144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
35145     return 0;
35146   }
35147   std::string arg2_str(jarg2);
35148   arg2 = &arg2_str;
35149   arg3 = (Dali::Handle *)jarg3;
35150   if (!arg3) {
35151     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
35152     return 0;
35153   }
35154   {
35155     try {
35156       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
35157     } CALL_CATCH_EXCEPTION(0);
35158   }
35159
35160   jresult = result;
35161
35162   //argout typemap for const std::string&
35163
35164   return jresult;
35165 }
35166
35167
35168 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
35169   unsigned int jresult ;
35170   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
35171   Dali::Handle *arg2 = 0 ;
35172   std::string *arg3 = 0 ;
35173   bool result;
35174
35175   arg1 = (Dali::Toolkit::Builder *)jarg1;
35176   arg2 = (Dali::Handle *)jarg2;
35177   if (!arg2) {
35178     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
35179     return 0;
35180   }
35181   if (!jarg3) {
35182     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
35183     return 0;
35184   }
35185   std::string arg3_str(jarg3);
35186   arg3 = &arg3_str;
35187   {
35188     try {
35189       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
35190     } CALL_CATCH_EXCEPTION(0);
35191   }
35192
35193   jresult = result;
35194
35195   //argout typemap for const std::string&
35196
35197   return jresult;
35198 }
35199
35200
35201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
35202   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
35203   Dali::Actor arg2 ;
35204   Dali::Actor *argp2 ;
35205
35206   arg1 = (Dali::Toolkit::Builder *)jarg1;
35207   argp2 = (Dali::Actor *)jarg2;
35208   if (!argp2) {
35209     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
35210     return ;
35211   }
35212   arg2 = *argp2;
35213   {
35214     try {
35215       (arg1)->AddActors(arg2);
35216     } CALL_CATCH_EXCEPTION();
35217   }
35218
35219 }
35220
35221
35222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
35223   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
35224   std::string *arg2 = 0 ;
35225   Dali::Actor arg3 ;
35226   Dali::Actor *argp3 ;
35227
35228   arg1 = (Dali::Toolkit::Builder *)jarg1;
35229   if (!jarg2) {
35230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
35231     return ;
35232   }
35233   std::string arg2_str(jarg2);
35234   arg2 = &arg2_str;
35235   argp3 = (Dali::Actor *)jarg3;
35236   if (!argp3) {
35237     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
35238     return ;
35239   }
35240   arg3 = *argp3;
35241   {
35242     try {
35243       (arg1)->AddActors((std::string const &)*arg2,arg3);
35244     } CALL_CATCH_EXCEPTION();
35245   }
35246
35247
35248   //argout typemap for const std::string&
35249
35250 }
35251
35252
35253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
35254   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
35255   std::string *arg2 = 0 ;
35256
35257   arg1 = (Dali::Toolkit::Builder *)jarg1;
35258   if (!jarg2) {
35259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
35260     return ;
35261   }
35262   std::string arg2_str(jarg2);
35263   arg2 = &arg2_str;
35264   {
35265     try {
35266       (arg1)->CreateRenderTask((std::string const &)*arg2);
35267     } CALL_CATCH_EXCEPTION();
35268   }
35269
35270
35271   //argout typemap for const std::string&
35272
35273 }
35274
35275
35276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
35277   void * jresult ;
35278   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
35279   std::string *arg2 = 0 ;
35280   Dali::Path result;
35281
35282   arg1 = (Dali::Toolkit::Builder *)jarg1;
35283   if (!jarg2) {
35284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
35285     return 0;
35286   }
35287   std::string arg2_str(jarg2);
35288   arg2 = &arg2_str;
35289   {
35290     try {
35291       result = (arg1)->GetPath((std::string const &)*arg2);
35292     } CALL_CATCH_EXCEPTION(0);
35293   }
35294
35295   jresult = new Dali::Path((const Dali::Path &)result);
35296
35297   //argout typemap for const std::string&
35298
35299   return jresult;
35300 }
35301
35302
35303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
35304   void * jresult ;
35305   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
35306   std::string *arg2 = 0 ;
35307   Dali::PathConstrainer result;
35308
35309   arg1 = (Dali::Toolkit::Builder *)jarg1;
35310   if (!jarg2) {
35311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
35312     return 0;
35313   }
35314   std::string arg2_str(jarg2);
35315   arg2 = &arg2_str;
35316   {
35317     try {
35318       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
35319     } CALL_CATCH_EXCEPTION(0);
35320   }
35321
35322   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
35323
35324   //argout typemap for const std::string&
35325
35326   return jresult;
35327 }
35328
35329
35330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
35331   void * jresult ;
35332   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
35333   std::string *arg2 = 0 ;
35334   Dali::LinearConstrainer result;
35335
35336   arg1 = (Dali::Toolkit::Builder *)jarg1;
35337   if (!jarg2) {
35338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
35339     return 0;
35340   }
35341   std::string arg2_str(jarg2);
35342   arg2 = &arg2_str;
35343   {
35344     try {
35345       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
35346     } CALL_CATCH_EXCEPTION(0);
35347   }
35348
35349   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
35350
35351   //argout typemap for const std::string&
35352
35353   return jresult;
35354 }
35355
35356
35357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
35358   void * jresult ;
35359   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
35360   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
35361
35362   arg1 = (Dali::Toolkit::Builder *)jarg1;
35363   {
35364     try {
35365       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
35366     } CALL_CATCH_EXCEPTION(0);
35367   }
35368
35369   jresult = (void *)result;
35370   return jresult;
35371 }
35372
35373
35374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
35375   void * jresult ;
35376   Dali::Toolkit::TransitionData *result = 0 ;
35377
35378   {
35379     try {
35380       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
35381     } CALL_CATCH_EXCEPTION(0);
35382   }
35383
35384   jresult = (void *)result;
35385   return jresult;
35386 }
35387
35388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
35389   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
35390
35391   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
35392   {
35393     try {
35394       delete arg1;
35395     } CALL_CATCH_EXCEPTION();
35396   }
35397
35398 }
35399
35400
35401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
35402   void * jresult ;
35403   Dali::Property::Map *arg1 = 0 ;
35404   Dali::Toolkit::TransitionData result;
35405
35406   arg1 = (Dali::Property::Map *)jarg1;
35407   if (!arg1) {
35408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
35409     return 0;
35410   }
35411   {
35412     try {
35413       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
35414     } CALL_CATCH_EXCEPTION(0);
35415   }
35416
35417   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
35418   return jresult;
35419 }
35420
35421
35422 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
35423   void * jresult ;
35424   Dali::Property::Array *arg1 = 0 ;
35425   Dali::Toolkit::TransitionData result;
35426
35427   arg1 = (Dali::Property::Array *)jarg1;
35428   if (!arg1) {
35429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
35430     return 0;
35431   }
35432   {
35433     try {
35434       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
35435     } CALL_CATCH_EXCEPTION(0);
35436   }
35437
35438   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
35439   return jresult;
35440 }
35441
35442
35443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
35444   void * jresult ;
35445   Dali::BaseHandle arg1 ;
35446   Dali::BaseHandle *argp1 ;
35447   Dali::Toolkit::TransitionData result;
35448
35449   argp1 = (Dali::BaseHandle *)jarg1;
35450   if (!argp1) {
35451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
35452     return 0;
35453   }
35454   arg1 = *argp1;
35455   {
35456     try {
35457       result = Dali::Toolkit::TransitionData::DownCast(arg1);
35458     } CALL_CATCH_EXCEPTION(0);
35459   }
35460
35461   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
35462   return jresult;
35463 }
35464
35465
35466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
35467   void * jresult ;
35468   Dali::Toolkit::TransitionData *arg1 = 0 ;
35469   Dali::Toolkit::TransitionData *result = 0 ;
35470
35471   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
35472   if (!arg1) {
35473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
35474     return 0;
35475   }
35476   {
35477     try {
35478       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
35479     } CALL_CATCH_EXCEPTION(0);
35480   }
35481
35482   jresult = (void *)result;
35483   return jresult;
35484 }
35485
35486
35487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
35488   void * jresult ;
35489   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
35490   Dali::Toolkit::TransitionData *arg2 = 0 ;
35491   Dali::Toolkit::TransitionData *result = 0 ;
35492
35493   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
35494   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
35495   if (!arg2) {
35496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
35497     return 0;
35498   }
35499   {
35500     try {
35501       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
35502     } CALL_CATCH_EXCEPTION(0);
35503   }
35504
35505   jresult = (void *)result;
35506   return jresult;
35507 }
35508
35509
35510 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
35511   unsigned long jresult ;
35512   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
35513   size_t result;
35514
35515   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
35516   {
35517     try {
35518       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
35519     } CALL_CATCH_EXCEPTION(0);
35520   }
35521
35522   jresult = (unsigned long)result;
35523   return jresult;
35524 }
35525
35526
35527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
35528   void * jresult ;
35529   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
35530   size_t arg2 ;
35531   Dali::Property::Map result;
35532
35533   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
35534   arg2 = (size_t)jarg2;
35535   {
35536     try {
35537       result = (arg1)->GetAnimatorAt(arg2);
35538     } CALL_CATCH_EXCEPTION(0);
35539   }
35540
35541   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
35542   return jresult;
35543 }
35544
35545
35546 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
35547   int jresult ;
35548   int result;
35549
35550   {
35551     try {
35552       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
35553     } CALL_CATCH_EXCEPTION(0);
35554   }
35555
35556   jresult = (int)result;
35557   return jresult;
35558 }
35559
35560
35561 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() {
35562   int jresult ;
35563   int result;
35564
35565   {
35566     try {
35567       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
35568     } CALL_CATCH_EXCEPTION(0);
35569   }
35570
35571   jresult = (int)result;
35572   return jresult;
35573 }
35574
35575
35576 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() {
35577   int jresult ;
35578   int result;
35579
35580   {
35581     try {
35582       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
35583     } CALL_CATCH_EXCEPTION(0);
35584   }
35585
35586   jresult = (int)result;
35587   return jresult;
35588 }
35589
35590
35591 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() {
35592   int jresult ;
35593   int result;
35594
35595   {
35596     try {
35597       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
35598     } CALL_CATCH_EXCEPTION(0);
35599   }
35600
35601   jresult = (int)result;
35602   return jresult;
35603 }
35604
35605
35606 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() {
35607   int jresult ;
35608   int result;
35609
35610   {
35611     try {
35612       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
35613     } CALL_CATCH_EXCEPTION(0);
35614   }
35615
35616   jresult = (int)result;
35617   return jresult;
35618 }
35619
35620
35621 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() {
35622   int jresult ;
35623   int result;
35624
35625   {
35626     try {
35627       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
35628     } CALL_CATCH_EXCEPTION(0);
35629   }
35630
35631   jresult = (int)result;
35632   return jresult;
35633 }
35634
35635
35636 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
35637   int jresult ;
35638   int result;
35639
35640   {
35641     try {
35642       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
35643     } CALL_CATCH_EXCEPTION(0);
35644   }
35645
35646   jresult = (int)result;
35647   return jresult;
35648 }
35649
35650
35651 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
35652   int jresult ;
35653   int result;
35654
35655   {
35656     try {
35657       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
35658     } CALL_CATCH_EXCEPTION(0);
35659   }
35660
35661   jresult = (int)result;
35662   return jresult;
35663 }
35664
35665
35666 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
35667   int jresult ;
35668   int result;
35669
35670   {
35671     try {
35672       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
35673     } CALL_CATCH_EXCEPTION(0);
35674   }
35675
35676   jresult = (int)result;
35677   return jresult;
35678 }
35679
35680
35681 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
35682   int jresult ;
35683   int result;
35684
35685   {
35686     try {
35687       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
35688     } CALL_CATCH_EXCEPTION(0);
35689   }
35690
35691   jresult = (int)result;
35692   return jresult;
35693 }
35694
35695
35696 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
35697   int jresult ;
35698   int result;
35699
35700   {
35701     try {
35702       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
35703     } CALL_CATCH_EXCEPTION(0);
35704   }
35705
35706   jresult = (int)result;
35707   return jresult;
35708 }
35709
35710
35711 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() {
35712   int jresult ;
35713   int result;
35714
35715   {
35716     try {
35717       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
35718     } CALL_CATCH_EXCEPTION(0);
35719   }
35720
35721   jresult = (int)result;
35722   return jresult;
35723 }
35724
35725
35726 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
35727   int jresult ;
35728   int result;
35729
35730   {
35731     try {
35732       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
35733     } CALL_CATCH_EXCEPTION(0);
35734   }
35735
35736   jresult = (int)result;
35737   return jresult;
35738 }
35739
35740
35741 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() {
35742   int jresult ;
35743   int result;
35744
35745   {
35746     try {
35747       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
35748     } CALL_CATCH_EXCEPTION(0);
35749   }
35750
35751   jresult = (int)result;
35752   return jresult;
35753 }
35754
35755
35756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
35757   void * jresult ;
35758   Dali::Toolkit::Control result;
35759
35760   {
35761     try {
35762       result = Dali::Toolkit::Internal::Control::New();
35763     } CALL_CATCH_EXCEPTION(0);
35764   }
35765
35766   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
35767   return jresult;
35768 }
35769
35770
35771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
35772   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
35773   std::string *arg2 = 0 ;
35774
35775   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
35776   if (!jarg2) {
35777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
35778     return ;
35779   }
35780   std::string arg2_str(jarg2);
35781   arg2 = &arg2_str;
35782   {
35783     try {
35784       (arg1)->SetStyleName((std::string const &)*arg2);
35785     } CALL_CATCH_EXCEPTION();
35786   }
35787
35788
35789   //argout typemap for const std::string&
35790
35791 }
35792
35793
35794 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
35795   char * jresult ;
35796   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
35797   std::string *result = 0 ;
35798
35799   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
35800   {
35801     try {
35802       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
35803     } CALL_CATCH_EXCEPTION(0);
35804   }
35805
35806   jresult = SWIG_csharp_string_callback(result->c_str());
35807   return jresult;
35808 }
35809
35810
35811 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
35812   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
35813   Dali::Vector4 *arg2 = 0 ;
35814
35815   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
35816   arg2 = (Dali::Vector4 *)jarg2;
35817   if (!arg2) {
35818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
35819     return ;
35820   }
35821   {
35822     try {
35823       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
35824     } CALL_CATCH_EXCEPTION();
35825   }
35826
35827 }
35828
35829
35830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
35831   void * jresult ;
35832   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
35833   Dali::Vector4 result;
35834
35835   arg1 = (Dali::Handle *)jarg1;
35836   {
35837     try {
35838       Property::Map* resultMap = ((arg1)->GetProperty( Control::Property::BACKGROUND )).GetMap();
35839       if (resultMap)
35840       {
35841         Dali::Property::Value* type = resultMap->Find( Toolkit::Visual::Property::TYPE );
35842         if(type && type->Get<int>() == Visual::COLOR )
35843         {
35844           Dali::Property::Value* value = resultMap->Find( ColorVisual::Property::MIX_COLOR );
35845           if (value)
35846           {
35847             result = value->Get<Vector4>();
35848           }
35849         }
35850       }
35851     } CALL_CATCH_EXCEPTION(0);
35852   }
35853
35854   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
35855   return jresult;
35856 }
35857
35858
35859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
35860   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
35861   Dali::Property::Map *arg2 = 0 ;
35862
35863   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
35864   arg2 = (Dali::Property::Map *)jarg2;
35865   if (!arg2) {
35866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
35867     return ;
35868   }
35869   {
35870     try {
35871       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
35872     } CALL_CATCH_EXCEPTION();
35873   }
35874
35875 }
35876
35877
35878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
35879   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
35880
35881   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
35882   {
35883     try {
35884       (arg1)->ClearBackground();
35885     } CALL_CATCH_EXCEPTION();
35886   }
35887
35888 }
35889
35890
35891 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
35892   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
35893   Dali::Gesture::Type arg2 ;
35894
35895   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
35896   arg2 = (Dali::Gesture::Type)jarg2;
35897   {
35898     try {
35899       (arg1)->EnableGestureDetection(arg2);
35900     } CALL_CATCH_EXCEPTION();
35901   }
35902
35903 }
35904
35905
35906 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
35907   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
35908   Dali::Gesture::Type arg2 ;
35909
35910   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
35911   arg2 = (Dali::Gesture::Type)jarg2;
35912   {
35913     try {
35914       (arg1)->DisableGestureDetection(arg2);
35915     } CALL_CATCH_EXCEPTION();
35916   }
35917
35918 }
35919
35920
35921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
35922   void * jresult ;
35923   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
35924   Dali::PinchGestureDetector result;
35925
35926   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
35927   {
35928     try {
35929       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
35930     } CALL_CATCH_EXCEPTION(0);
35931   }
35932
35933   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
35934   return jresult;
35935 }
35936
35937
35938 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
35939   void * jresult ;
35940   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
35941   Dali::PanGestureDetector result;
35942
35943   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
35944   {
35945     try {
35946       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
35947     } CALL_CATCH_EXCEPTION(0);
35948   }
35949
35950   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
35951   return jresult;
35952 }
35953
35954
35955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
35956   void * jresult ;
35957   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
35958   Dali::TapGestureDetector result;
35959
35960   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
35961   {
35962     try {
35963       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
35964     } CALL_CATCH_EXCEPTION(0);
35965   }
35966
35967   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
35968   return jresult;
35969 }
35970
35971
35972 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
35973   void * jresult ;
35974   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
35975   Dali::LongPressGestureDetector result;
35976
35977   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
35978   {
35979     try {
35980       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
35981     } CALL_CATCH_EXCEPTION(0);
35982   }
35983
35984   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
35985   return jresult;
35986 }
35987
35988
35989 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, unsigned int jarg2) {
35990   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
35991   bool arg2 ;
35992
35993   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
35994   arg2 = jarg2 ? true : false;
35995   {
35996     try {
35997       (arg1)->SetKeyboardNavigationSupport(arg2);
35998     } CALL_CATCH_EXCEPTION();
35999   }
36000
36001 }
36002
36003
36004 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
36005   unsigned int jresult ;
36006   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36007   bool result;
36008
36009   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36010   {
36011     try {
36012       result = (bool)(arg1)->IsKeyboardNavigationSupported();
36013     } CALL_CATCH_EXCEPTION(0);
36014   }
36015
36016   jresult = result;
36017   return jresult;
36018 }
36019
36020
36021 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
36022   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36023
36024   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36025   {
36026     try {
36027       (arg1)->SetKeyInputFocus();
36028     } CALL_CATCH_EXCEPTION();
36029   }
36030
36031 }
36032
36033
36034 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
36035   unsigned int jresult ;
36036   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36037   bool result;
36038
36039   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36040   {
36041     try {
36042       result = (bool)(arg1)->HasKeyInputFocus();
36043     } CALL_CATCH_EXCEPTION(0);
36044   }
36045
36046   jresult = result;
36047   return jresult;
36048 }
36049
36050
36051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
36052   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36053
36054   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36055   {
36056     try {
36057       (arg1)->ClearKeyInputFocus();
36058     } CALL_CATCH_EXCEPTION();
36059   }
36060
36061 }
36062
36063
36064 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, unsigned int jarg2) {
36065   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36066   bool arg2 ;
36067
36068   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36069   arg2 = jarg2 ? true : false;
36070   {
36071     try {
36072       (arg1)->SetAsKeyboardFocusGroup(arg2);
36073     } CALL_CATCH_EXCEPTION();
36074   }
36075
36076 }
36077
36078
36079 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
36080   unsigned int jresult ;
36081   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36082   bool result;
36083
36084   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36085   {
36086     try {
36087       result = (bool)(arg1)->IsKeyboardFocusGroup();
36088     } CALL_CATCH_EXCEPTION(0);
36089   }
36090
36091   jresult = result;
36092   return jresult;
36093 }
36094
36095
36096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
36097   void * jresult ;
36098   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36099   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
36100
36101   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36102   {
36103     try {
36104       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
36105     } CALL_CATCH_EXCEPTION(0);
36106   }
36107
36108   jresult = (void *)result;
36109   return jresult;
36110 }
36111
36112
36113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
36114   void * jresult ;
36115   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36116   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
36117
36118   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36119   {
36120     try {
36121       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
36122     } CALL_CATCH_EXCEPTION(0);
36123   }
36124
36125   jresult = (void *)result;
36126   return jresult;
36127 }
36128
36129
36130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(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)->KeyInputFocusLostSignal();
36139     } CALL_CATCH_EXCEPTION(0);
36140   }
36141
36142   jresult = (void *)result;
36143   return jresult;
36144 }
36145
36146
36147 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneConnection(void * jarg1, int jarg2) {
36148   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36149   int arg2 ;
36150   SwigDirector_ViewImpl *darg = 0;
36151
36152   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36153   arg2 = (int)jarg2;
36154   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36155   if(!darg) {
36156     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36157     return;
36158   }
36159   {
36160     try {
36161       if(darg) {
36162         (darg)->OnSceneConnection(arg2);
36163       }
36164     } CALL_CATCH_EXCEPTION();
36165   }
36166
36167 }
36168
36169
36170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
36171   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36172   int arg2 ;
36173   SwigDirector_ViewImpl *darg = 0;
36174
36175   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36176   arg2 = (int)jarg2;
36177   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36178   if(!darg) {
36179     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36180     return;
36181   }
36182   {
36183     try {
36184       if(darg) {
36185         (darg)->OnSceneConnectionSwigPublic(arg2);
36186       }
36187     } CALL_CATCH_EXCEPTION();
36188   }
36189
36190 }
36191
36192
36193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneDisconnection(void * jarg1) {
36194   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36195   SwigDirector_ViewImpl *darg = 0;
36196
36197   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36198   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36199   if(!darg) {
36200     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36201     return;
36202   }
36203   {
36204     try {
36205       if(darg) {
36206         (darg)->OnSceneDisconnection();
36207       }
36208     } CALL_CATCH_EXCEPTION();
36209   }
36210
36211 }
36212
36213
36214 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneDisconnectionSwigExplicitViewImpl(void * jarg1) {
36215   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36216   SwigDirector_ViewImpl *darg = 0;
36217
36218   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36219   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36220   if(!darg) {
36221     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36222     return;
36223   }
36224   {
36225     try {
36226       if(darg) {
36227         (darg)->OnSceneDisconnectionSwigPublic();
36228       }
36229     } CALL_CATCH_EXCEPTION();
36230   }
36231
36232 }
36233
36234
36235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
36236   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36237   Dali::Actor *arg2 = 0 ;
36238   SwigDirector_ViewImpl *darg = 0;
36239
36240   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36241   arg2 = (Dali::Actor *)jarg2;
36242   if (!arg2) {
36243     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
36244     return ;
36245   }
36246   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36247   if(!darg) {
36248     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36249     return;
36250   }
36251   {
36252     try {
36253       if(darg) {
36254         (darg)->OnChildAdd(*arg2);
36255       }
36256     } CALL_CATCH_EXCEPTION();
36257   }
36258
36259 }
36260
36261
36262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
36263   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36264   Dali::Actor *arg2 = 0 ;
36265   SwigDirector_ViewImpl *darg = 0;
36266
36267   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36268   arg2 = (Dali::Actor *)jarg2;
36269   if (!arg2) {
36270     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
36271     return ;
36272   }
36273   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36274   if(!darg) {
36275     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36276     return;
36277   }
36278   {
36279     try {
36280       if(darg) {
36281           (darg)->OnChildAddSwigPublic(*arg2);
36282       }
36283     } CALL_CATCH_EXCEPTION();
36284   }
36285
36286 }
36287
36288
36289 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
36290   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36291   Dali::Actor *arg2 = 0 ;
36292   SwigDirector_ViewImpl *darg = 0;
36293
36294   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36295   arg2 = (Dali::Actor *)jarg2;
36296   if (!arg2) {
36297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
36298     return ;
36299   }
36300   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36301   if(!darg) {
36302     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36303     return;
36304   }
36305   {
36306     try {
36307       if(darg) {
36308         (darg)->OnChildRemove(*arg2);
36309       }
36310     } CALL_CATCH_EXCEPTION();
36311   }
36312
36313 }
36314
36315
36316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
36317   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36318   Dali::Actor *arg2 = 0 ;
36319   SwigDirector_ViewImpl *darg = 0;
36320
36321   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36322   arg2 = (Dali::Actor *)jarg2;
36323   if (!arg2) {
36324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
36325     return ;
36326   }
36327   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36328   if(!darg) {
36329     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36330     return;
36331   }
36332   {
36333     try {
36334       if(darg) {
36335         (darg)->OnChildRemoveSwigPublic(*arg2);
36336       }
36337     } CALL_CATCH_EXCEPTION();
36338   }
36339
36340 }
36341
36342
36343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
36344   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36345   Dali::Property::Index arg2 ;
36346   Dali::Property::Value arg3 ;
36347   Dali::Property::Value *argp3 ;
36348   SwigDirector_ViewImpl *darg = 0;
36349
36350   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36351   arg2 = (Dali::Property::Index)jarg2;
36352   argp3 = (Dali::Property::Value *)jarg3;
36353   if (!argp3) {
36354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
36355     return ;
36356   }
36357   arg3 = *argp3;
36358   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36359   if (!darg) {
36360     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36361     return;
36362   }
36363   {
36364     try {
36365       (darg)->OnPropertySet(arg2,arg3);
36366     } CALL_CATCH_EXCEPTION();
36367   }
36368
36369 }
36370
36371
36372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
36373   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36374   Dali::Vector3 *arg2 = 0 ;
36375   SwigDirector_ViewImpl *darg = 0;
36376
36377   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36378   arg2 = (Dali::Vector3 *)jarg2;
36379   if (!arg2) {
36380     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
36381     return ;
36382   }
36383   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36384   if (!darg) {
36385     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36386     return;
36387   }
36388   {
36389     try {
36390       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
36391     } CALL_CATCH_EXCEPTION();
36392   }
36393
36394 }
36395
36396
36397 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
36398   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36399   Dali::Vector3 *arg2 = 0 ;
36400   SwigDirector_ViewImpl *darg = 0;
36401
36402   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36403   arg2 = (Dali::Vector3 *)jarg2;
36404   if (!arg2) {
36405     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
36406     return ;
36407   }
36408   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36409   if (!darg) {
36410     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36411     return;
36412   }
36413   {
36414     try {
36415       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
36416     } CALL_CATCH_EXCEPTION();
36417   }
36418
36419 }
36420
36421
36422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
36423   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36424   Dali::Animation *arg2 = 0 ;
36425   Dali::Vector3 *arg3 = 0 ;
36426   SwigDirector_ViewImpl *darg = 0;
36427
36428   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36429   arg2 = (Dali::Animation *)jarg2;
36430   if (!arg2) {
36431     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
36432     return ;
36433   }
36434   arg3 = (Dali::Vector3 *)jarg3;
36435   if (!arg3) {
36436     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
36437     return ;
36438   }
36439   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36440   if (!darg) {
36441     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36442     return;
36443   }
36444   {
36445     try {
36446       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
36447     } CALL_CATCH_EXCEPTION();
36448   }
36449
36450 }
36451
36452
36453 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
36454   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36455   Dali::Animation *arg2 = 0 ;
36456   Dali::Vector3 *arg3 = 0 ;
36457   SwigDirector_ViewImpl *darg = 0;
36458
36459   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36460   arg2 = (Dali::Animation *)jarg2;
36461   if (!arg2) {
36462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
36463     return ;
36464   }
36465   arg3 = (Dali::Vector3 *)jarg3;
36466   if (!arg3) {
36467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
36468     return ;
36469   }
36470   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36471   if (!darg) {
36472     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36473     return;
36474   }
36475   {
36476     try {
36477       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
36478     } CALL_CATCH_EXCEPTION();
36479   }
36480 }
36481
36482
36483 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEvent(void * jarg1, void * jarg2) {
36484   unsigned int jresult ;
36485   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36486   Dali::HoverEvent *arg2 = 0 ;
36487   SwigDirector_ViewImpl *darg = 0;
36488   bool result;
36489
36490   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36491   arg2 = (Dali::HoverEvent *)jarg2;
36492   if (!arg2) {
36493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
36494     return 0;
36495   }
36496   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36497   if (!darg) {
36498     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36499     return 0;
36500   }
36501   {
36502     try {
36503       result = (bool)(darg)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
36504     } CALL_CATCH_EXCEPTION(0);
36505   }
36506
36507   jresult = result;
36508   return jresult;
36509 }
36510
36511
36512 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
36513   unsigned int jresult ;
36514   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36515   Dali::HoverEvent *arg2 = 0 ;
36516   SwigDirector_ViewImpl *darg = 0;
36517   bool result;
36518
36519   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36520   arg2 = (Dali::HoverEvent *)jarg2;
36521   if (!arg2) {
36522     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
36523     return 0;
36524   }
36525   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36526   if (!darg) {
36527     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36528     return 0;
36529   }
36530   {
36531     try {
36532       result = (bool)(darg)->OnHoverEventSwigPublic((Dali::HoverEvent const &)*arg2);
36533     } CALL_CATCH_EXCEPTION(0);
36534   }
36535
36536   jresult = result;
36537   return jresult;
36538 }
36539
36540
36541 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
36542   unsigned int jresult ;
36543   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36544   Dali::KeyEvent *arg2 = 0 ;
36545   SwigDirector_ViewImpl *darg = 0;
36546   bool result;
36547
36548   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36549   arg2 = (Dali::KeyEvent *)jarg2;
36550   if (!arg2) {
36551     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
36552     return 0;
36553   }
36554   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36555   if (!darg) {
36556     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36557     return 0;
36558   }
36559   {
36560     try {
36561       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
36562     } CALL_CATCH_EXCEPTION(0);
36563   }
36564
36565   jresult = result;
36566   return jresult;
36567 }
36568
36569
36570 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
36571   unsigned int jresult ;
36572   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36573   Dali::KeyEvent *arg2 = 0 ;
36574   SwigDirector_ViewImpl *darg = 0;
36575   bool result;
36576
36577   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36578   arg2 = (Dali::KeyEvent *)jarg2;
36579   if (!arg2) {
36580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
36581     return 0;
36582   }
36583   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36584   if (!darg) {
36585     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36586     return 0;
36587   }
36588   {
36589     try {
36590       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
36591     } CALL_CATCH_EXCEPTION(0);
36592   }
36593
36594   jresult = result;
36595   return jresult;
36596 }
36597
36598
36599 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEvent(void * jarg1, void * jarg2) {
36600   unsigned int jresult ;
36601   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36602   Dali::WheelEvent *arg2 = 0 ;
36603   SwigDirector_ViewImpl *darg = 0;
36604   bool result;
36605
36606   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36607   arg2 = (Dali::WheelEvent *)jarg2;
36608   if (!arg2) {
36609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
36610     return 0;
36611   }
36612   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36613   if (!darg) {
36614     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36615     return 0;
36616   }
36617   {
36618     try {
36619       result = (bool)(darg)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
36620     } CALL_CATCH_EXCEPTION(0);
36621   }
36622
36623   jresult = result;
36624   return jresult;
36625 }
36626
36627
36628 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
36629   unsigned int jresult ;
36630   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36631   Dali::WheelEvent *arg2 = 0 ;
36632   SwigDirector_ViewImpl *darg = 0;
36633   bool result;
36634
36635   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36636   arg2 = (Dali::WheelEvent *)jarg2;
36637   if (!arg2) {
36638     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
36639     return 0;
36640   }
36641   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36642   if (!darg) {
36643     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36644     return 0;
36645   }
36646   {
36647     try {
36648       result = (bool)(darg)->OnWheelEventSwigPublic((Dali::WheelEvent const &)*arg2);
36649     } CALL_CATCH_EXCEPTION(0);
36650   }
36651
36652   jresult = result;
36653   return jresult;
36654 }
36655
36656
36657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
36658   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36659   Dali::Vector2 *arg2 = 0 ;
36660   Dali::RelayoutContainer *arg3 = 0 ;
36661   SwigDirector_ViewImpl *darg = 0;
36662
36663   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36664   arg2 = (Dali::Vector2 *)jarg2;
36665   if (!arg2) {
36666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36667     return ;
36668   }
36669   arg3 = (Dali::RelayoutContainer *)jarg3;
36670   if (!arg3) {
36671     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
36672     return ;
36673   }
36674   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36675   if (!darg) {
36676     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36677     return;
36678   }
36679   {
36680     try {
36681       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
36682     } CALL_CATCH_EXCEPTION();
36683   }
36684
36685 }
36686
36687
36688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
36689   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36690   Dali::Vector2 *arg2 = 0 ;
36691   Dali::RelayoutContainer *arg3 = 0 ;
36692   SwigDirector_ViewImpl *darg = 0;
36693
36694   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36695   arg2 = (Dali::Vector2 *)jarg2;
36696   if (!arg2) {
36697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36698     return ;
36699   }
36700   arg3 = (Dali::RelayoutContainer *)jarg3;
36701   if (!arg3) {
36702     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
36703     return ;
36704   }
36705   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36706   if (!darg) {
36707     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36708     return;
36709   }
36710   {
36711     try {
36712       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
36713     } CALL_CATCH_EXCEPTION();
36714   }
36715
36716 }
36717
36718
36719 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
36720   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36721   Dali::ResizePolicy::Type arg2 ;
36722   Dali::Dimension::Type arg3 ;
36723   SwigDirector_ViewImpl *darg = 0;
36724
36725   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36726   arg2 = (Dali::ResizePolicy::Type)jarg2;
36727   arg3 = (Dali::Dimension::Type)jarg3;
36728   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36729   if (!darg) {
36730     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36731     return;
36732   }
36733   {
36734     try {
36735       (darg)->OnSetResizePolicy(arg2,arg3);
36736     } CALL_CATCH_EXCEPTION();
36737   }
36738
36739 }
36740
36741
36742 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
36743   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36744   Dali::ResizePolicy::Type arg2 ;
36745   Dali::Dimension::Type arg3 ;
36746   SwigDirector_ViewImpl *darg = 0;
36747
36748   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36749   arg2 = (Dali::ResizePolicy::Type)jarg2;
36750   arg3 = (Dali::Dimension::Type)jarg3;
36751   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36752   if (!darg) {
36753     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36754     return;
36755   }
36756   {
36757     try {
36758       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
36759     } CALL_CATCH_EXCEPTION();
36760   }
36761
36762 }
36763
36764
36765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
36766   void * jresult ;
36767   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36768   SwigDirector_ViewImpl *darg = 0;
36769   Dali::Vector3 result;
36770
36771   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36772   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36773   if (!darg) {
36774     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36775     return 0;
36776   }
36777   {
36778     try {
36779       result = (darg)->GetNaturalSize();
36780     } CALL_CATCH_EXCEPTION(0);
36781   }
36782
36783   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
36784   return jresult;
36785 }
36786
36787
36788 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
36789   void * jresult ;
36790   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36791   SwigDirector_ViewImpl *darg = 0;
36792   Dali::Vector3 result;
36793
36794   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36795   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36796   if (!darg) {
36797     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36798     return 0;
36799   }
36800   {
36801     try {
36802       result = (darg)->GetNaturalSizeSwigPublic();
36803     } CALL_CATCH_EXCEPTION(0);
36804   }
36805
36806   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
36807   return jresult;
36808 }
36809
36810
36811 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
36812   float jresult ;
36813   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36814   Dali::Actor *arg2 = 0 ;
36815   Dali::Dimension::Type arg3 ;
36816   SwigDirector_ViewImpl *darg = 0;
36817   float result;
36818
36819   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36820   arg2 = (Dali::Actor *)jarg2;
36821   if (!arg2) {
36822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
36823     return 0;
36824   }
36825   arg3 = (Dali::Dimension::Type)jarg3;
36826   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36827   if (!darg) {
36828     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36829     return 0;
36830   }
36831   {
36832     try {
36833       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
36834     } CALL_CATCH_EXCEPTION(0);
36835   }
36836
36837   jresult = result;
36838   return jresult;
36839 }
36840
36841
36842 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
36843   float jresult ;
36844   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36845   Dali::Actor *arg2 = 0 ;
36846   Dali::Dimension::Type arg3 ;
36847   SwigDirector_ViewImpl *darg = 0;
36848   float result;
36849
36850   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36851   arg2 = (Dali::Actor *)jarg2;
36852   if (!arg2) {
36853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
36854     return 0;
36855   }
36856   arg3 = (Dali::Dimension::Type)jarg3;
36857   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36858   if (!darg) {
36859     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36860     return 0;
36861   }
36862   {
36863     try {
36864       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
36865     } CALL_CATCH_EXCEPTION(0);
36866   }
36867
36868   jresult = result;
36869   return jresult;
36870 }
36871
36872
36873 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
36874   float jresult ;
36875   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36876   float arg2 ;
36877   SwigDirector_ViewImpl *darg = 0;
36878   float result;
36879
36880   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36881   arg2 = (float)jarg2;
36882   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36883   if (!darg) {
36884     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36885     return 0;
36886   }
36887   {
36888     try {
36889       result = (float)(darg)->GetHeightForWidth(arg2);
36890     } CALL_CATCH_EXCEPTION(0);
36891   }
36892
36893   jresult = result;
36894   return jresult;
36895 }
36896
36897
36898 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
36899   float jresult ;
36900   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36901   float arg2 ;
36902   SwigDirector_ViewImpl *darg = 0;
36903   float result;
36904
36905   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36906   arg2 = (float)jarg2;
36907   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36908   if (!darg) {
36909     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36910     return 0;
36911   }
36912   {
36913     try {
36914       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
36915     } CALL_CATCH_EXCEPTION(0);
36916   }
36917
36918   jresult = result;
36919   return jresult;
36920 }
36921
36922
36923 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
36924   float jresult ;
36925   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36926   float arg2 ;
36927   SwigDirector_ViewImpl *darg = 0;
36928   float result;
36929
36930   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36931   arg2 = (float)jarg2;
36932   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36933   if (!darg) {
36934     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36935     return 0;
36936   }
36937   {
36938     try {
36939       result = (float)(darg)->GetWidthForHeight(arg2);
36940     } CALL_CATCH_EXCEPTION(0);
36941   }
36942
36943   jresult = result;
36944   return jresult;
36945 }
36946
36947
36948 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
36949   float jresult ;
36950   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36951   float arg2 ;
36952   SwigDirector_ViewImpl *darg = 0;
36953   float result;
36954
36955   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36956   arg2 = (float)jarg2;
36957   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36958   if (!darg) {
36959     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36960     return 0;
36961   }
36962   {
36963     try {
36964       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
36965     } CALL_CATCH_EXCEPTION(0);
36966   }
36967
36968   jresult = result;
36969   return jresult;
36970 }
36971
36972
36973 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
36974   unsigned int jresult ;
36975   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
36976   Dali::Dimension::Type arg2 ;
36977   SwigDirector_ViewImpl *darg = 0;
36978   bool result;
36979
36980   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
36981   arg2 = (Dali::Dimension::Type)jarg2;
36982   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
36983   if (!darg) {
36984     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
36985     return 0;
36986   }
36987   {
36988     try {
36989       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
36990     } CALL_CATCH_EXCEPTION(0);
36991   }
36992
36993   jresult = result;
36994   return jresult;
36995 }
36996
36997
36998 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
36999   unsigned int jresult ;
37000   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37001   Dali::Dimension::Type arg2 ;
37002   SwigDirector_ViewImpl *darg = 0;
37003   bool result;
37004
37005   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37006   arg2 = (Dali::Dimension::Type)jarg2;
37007   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
37008   if (!darg) {
37009     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
37010     return 0;
37011   }
37012   {
37013     try {
37014       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
37015     } CALL_CATCH_EXCEPTION(0);
37016   }
37017
37018   jresult = result;
37019   return jresult;
37020 }
37021
37022
37023 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
37024   unsigned int jresult ;
37025   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37026   SwigDirector_ViewImpl *darg = 0;
37027   bool result;
37028
37029   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37030   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
37031   if (!darg) {
37032     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
37033     return 0;
37034   }
37035   {
37036     try {
37037       result = (bool)(darg)->RelayoutDependentOnChildren();
37038     } CALL_CATCH_EXCEPTION(0);
37039   }
37040
37041   jresult = result;
37042   return jresult;
37043 }
37044
37045
37046 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
37047   unsigned int jresult ;
37048   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37049   SwigDirector_ViewImpl *darg = 0;
37050   bool result;
37051
37052   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37053   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
37054   if (!darg) {
37055     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
37056     return 0;
37057   }
37058   {
37059     try {
37060       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
37061     } CALL_CATCH_EXCEPTION(0);
37062   }
37063
37064   jresult = result;
37065   return jresult;
37066 }
37067
37068
37069 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
37070   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37071   Dali::Dimension::Type arg2 ;
37072   SwigDirector_ViewImpl *darg = 0;
37073
37074   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37075   arg2 = (Dali::Dimension::Type)jarg2;
37076   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
37077   if (!darg) {
37078     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
37079     return;
37080   }
37081   {
37082     try {
37083       (darg)->OnCalculateRelayoutSize(arg2);
37084     } CALL_CATCH_EXCEPTION();
37085   }
37086
37087 }
37088
37089
37090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
37091   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37092   Dali::Dimension::Type arg2 ;
37093   SwigDirector_ViewImpl *darg = 0;
37094
37095   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37096   arg2 = (Dali::Dimension::Type)jarg2;
37097   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
37098   if (!darg) {
37099     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
37100     return;
37101   }
37102   {
37103     try {
37104       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
37105     } CALL_CATCH_EXCEPTION();
37106   }
37107
37108 }
37109
37110
37111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
37112   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37113   float arg2 ;
37114   Dali::Dimension::Type arg3 ;
37115   SwigDirector_ViewImpl *darg = 0;
37116
37117   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37118   arg2 = (float)jarg2;
37119   arg3 = (Dali::Dimension::Type)jarg3;
37120   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
37121   if (!darg) {
37122     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
37123     return;
37124   }
37125   {
37126     try {
37127       (darg)->OnLayoutNegotiated(arg2,arg3);
37128     } CALL_CATCH_EXCEPTION();
37129   }
37130
37131 }
37132
37133
37134 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
37135   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37136   float arg2 ;
37137   Dali::Dimension::Type arg3 ;
37138   SwigDirector_ViewImpl *darg = 0;
37139
37140   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37141   arg2 = (float)jarg2;
37142   arg3 = (Dali::Dimension::Type)jarg3;
37143   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
37144   if (!darg) {
37145     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
37146     return;
37147   }
37148   {
37149     try {
37150       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
37151     } CALL_CATCH_EXCEPTION();
37152   }
37153
37154 }
37155
37156
37157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
37158   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37159
37160   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37161   {
37162     try {
37163       (arg1)->OnInitialize();
37164     } CALL_CATCH_EXCEPTION();
37165   }
37166
37167 }
37168
37169
37170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
37171   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37172
37173   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37174   {
37175     try {
37176       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
37177     } CALL_CATCH_EXCEPTION();
37178   }
37179
37180 }
37181
37182
37183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
37184   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37185   Dali::Toolkit::StyleManager arg2 ;
37186   Dali::StyleChange::Type arg3 ;
37187   Dali::Toolkit::StyleManager *argp2 ;
37188
37189   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37190   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
37191   if (!argp2) {
37192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
37193     return ;
37194   }
37195   arg2 = *argp2;
37196   arg3 = (Dali::StyleChange::Type)jarg3;
37197   {
37198     try {
37199       (arg1)->OnStyleChange(arg2,arg3);
37200     } CALL_CATCH_EXCEPTION();
37201   }
37202
37203 }
37204
37205
37206 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
37207   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37208   Dali::Toolkit::StyleManager arg2 ;
37209   Dali::StyleChange::Type arg3 ;
37210   Dali::Toolkit::StyleManager *argp2 ;
37211
37212   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37213   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
37214   if (!argp2) {
37215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
37216     return ;
37217   }
37218   arg2 = *argp2;
37219   arg3 = (Dali::StyleChange::Type)jarg3;
37220   {
37221     try {
37222       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
37223     } CALL_CATCH_EXCEPTION();
37224   }
37225
37226 }
37227
37228
37229 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
37230   unsigned int jresult ;
37231   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37232   bool result;
37233
37234   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37235   {
37236     try {
37237       result = (bool)(arg1)->OnAccessibilityActivated();
37238     } CALL_CATCH_EXCEPTION(0);
37239   }
37240
37241   jresult = result;
37242   return jresult;
37243 }
37244
37245
37246 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(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)->Dali::Toolkit::Internal::Control::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_OnAccessibilityPan(void * jarg1, void * jarg2) {
37264   unsigned int jresult ;
37265   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37266   Dali::PanGesture arg2 ;
37267   Dali::PanGesture *argp2 ;
37268   bool result;
37269
37270   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37271   argp2 = (Dali::PanGesture *)jarg2;
37272   if (!argp2) {
37273     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
37274     return 0;
37275   }
37276   arg2 = *argp2;
37277   {
37278     try {
37279       result = (bool)(arg1)->OnAccessibilityPan(arg2);
37280     } CALL_CATCH_EXCEPTION(0);
37281   }
37282
37283   jresult = result;
37284   return jresult;
37285 }
37286
37287
37288 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
37289   unsigned int jresult ;
37290   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37291   Dali::PanGesture arg2 ;
37292   Dali::PanGesture *argp2 ;
37293   bool result;
37294
37295   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37296   argp2 = (Dali::PanGesture *)jarg2;
37297   if (!argp2) {
37298     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
37299     return 0;
37300   }
37301   arg2 = *argp2;
37302   {
37303     try {
37304       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
37305     } CALL_CATCH_EXCEPTION(0);
37306   }
37307
37308   jresult = result;
37309   return jresult;
37310 }
37311
37312 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, unsigned int jarg2) {
37313   unsigned int jresult ;
37314   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37315   bool arg2 ;
37316   bool result;
37317
37318   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37319   arg2 = jarg2 ? true : false;
37320   {
37321     try {
37322       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
37323     } CALL_CATCH_EXCEPTION(0);
37324   }
37325
37326   jresult = result;
37327   return jresult;
37328 }
37329
37330
37331 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, unsigned int jarg2) {
37332   unsigned int jresult ;
37333   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37334   bool arg2 ;
37335   bool result;
37336
37337   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37338   arg2 = jarg2 ? true : false;
37339   {
37340     try {
37341       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
37342     } CALL_CATCH_EXCEPTION(0);
37343   }
37344
37345   jresult = result;
37346   return jresult;
37347 }
37348
37349
37350 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
37351   unsigned int jresult ;
37352   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37353   bool result;
37354
37355   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37356   {
37357     try {
37358       result = (bool)(arg1)->OnAccessibilityZoom();
37359     } CALL_CATCH_EXCEPTION(0);
37360   }
37361
37362   jresult = result;
37363   return jresult;
37364 }
37365
37366
37367 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(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)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
37376     } CALL_CATCH_EXCEPTION(0);
37377   }
37378
37379   jresult = result;
37380   return jresult;
37381 }
37382
37383
37384 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
37385   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37386
37387   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37388   {
37389     try {
37390       (arg1)->OnKeyInputFocusGained();
37391     } CALL_CATCH_EXCEPTION();
37392   }
37393
37394 }
37395
37396
37397 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
37398   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37399
37400   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37401   {
37402     try {
37403       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
37404     } CALL_CATCH_EXCEPTION();
37405   }
37406
37407 }
37408
37409
37410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
37411   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37412
37413   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37414   {
37415     try {
37416       (arg1)->OnKeyInputFocusLost();
37417     } CALL_CATCH_EXCEPTION();
37418   }
37419
37420 }
37421
37422
37423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
37424   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37425
37426   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37427   {
37428     try {
37429       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
37430     } CALL_CATCH_EXCEPTION();
37431   }
37432
37433 }
37434
37435
37436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
37437   void * jresult ;
37438   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37439   Dali::Actor arg2 ;
37440   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
37441   bool arg4 ;
37442   Dali::Actor *argp2 ;
37443   Dali::Actor result;
37444
37445   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37446   argp2 = (Dali::Actor *)jarg2;
37447   if (!argp2) {
37448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
37449     return 0;
37450   }
37451   arg2 = *argp2;
37452   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
37453   arg4 = jarg4 ? true : false;
37454   {
37455     try {
37456       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
37457     } CALL_CATCH_EXCEPTION(0);
37458   }
37459
37460   jresult = new Dali::Actor((const Dali::Actor &)result);
37461   return jresult;
37462 }
37463
37464
37465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
37466   void * jresult ;
37467   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37468   Dali::Actor arg2 ;
37469   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
37470   bool arg4 ;
37471   Dali::Actor *argp2 ;
37472   Dali::Actor result;
37473
37474   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37475   argp2 = (Dali::Actor *)jarg2;
37476   if (!argp2) {
37477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
37478     return 0;
37479   }
37480   arg2 = *argp2;
37481   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
37482   arg4 = jarg4 ? true : false;
37483   {
37484     try {
37485       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
37486     } CALL_CATCH_EXCEPTION(0);
37487   }
37488
37489   jresult = new Dali::Actor((const Dali::Actor &)result);
37490   return jresult;
37491 }
37492
37493
37494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
37495   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37496   Dali::Actor arg2 ;
37497   Dali::Actor *argp2 ;
37498
37499   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37500   argp2 = (Dali::Actor *)jarg2;
37501   if (!argp2) {
37502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
37503     return ;
37504   }
37505   arg2 = *argp2;
37506   {
37507     try {
37508       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
37509     } CALL_CATCH_EXCEPTION();
37510   }
37511
37512 }
37513
37514
37515 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
37516   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37517   Dali::Actor arg2 ;
37518   Dali::Actor *argp2 ;
37519
37520   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37521   argp2 = (Dali::Actor *)jarg2;
37522   if (!argp2) {
37523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
37524     return ;
37525   }
37526   arg2 = *argp2;
37527   {
37528     try {
37529       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
37530     } CALL_CATCH_EXCEPTION();
37531   }
37532
37533 }
37534
37535
37536 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
37537   unsigned int jresult ;
37538   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37539   bool result;
37540
37541   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37542   {
37543     try {
37544       result = (bool)(arg1)->OnKeyboardEnter();
37545     } CALL_CATCH_EXCEPTION(0);
37546   }
37547
37548   jresult = result;
37549   return jresult;
37550 }
37551
37552
37553 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(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)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
37562     } CALL_CATCH_EXCEPTION(0);
37563   }
37564
37565   jresult = result;
37566   return jresult;
37567 }
37568
37569
37570 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
37571   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37572   Dali::PinchGesture *arg2 = 0 ;
37573
37574   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37575   arg2 = (Dali::PinchGesture *)jarg2;
37576   if (!arg2) {
37577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
37578     return ;
37579   }
37580   {
37581     try {
37582       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
37583     } CALL_CATCH_EXCEPTION();
37584   }
37585
37586 }
37587
37588
37589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
37590   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37591   Dali::PinchGesture *arg2 = 0 ;
37592
37593   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37594   arg2 = (Dali::PinchGesture *)jarg2;
37595   if (!arg2) {
37596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
37597     return ;
37598   }
37599   {
37600     try {
37601       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
37602     } CALL_CATCH_EXCEPTION();
37603   }
37604
37605 }
37606
37607
37608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
37609   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37610   Dali::PanGesture *arg2 = 0 ;
37611
37612   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37613   arg2 = (Dali::PanGesture *)jarg2;
37614   if (!arg2) {
37615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
37616     return ;
37617   }
37618   {
37619     try {
37620       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
37621     } CALL_CATCH_EXCEPTION();
37622   }
37623
37624 }
37625
37626
37627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
37628   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37629   Dali::PanGesture *arg2 = 0 ;
37630
37631   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37632   arg2 = (Dali::PanGesture *)jarg2;
37633   if (!arg2) {
37634     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
37635     return ;
37636   }
37637   {
37638     try {
37639       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
37640     } CALL_CATCH_EXCEPTION();
37641   }
37642
37643 }
37644
37645
37646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
37647   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37648   Dali::TapGesture *arg2 = 0 ;
37649
37650   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37651   arg2 = (Dali::TapGesture *)jarg2;
37652   if (!arg2) {
37653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
37654     return ;
37655   }
37656   {
37657     try {
37658       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
37659     } CALL_CATCH_EXCEPTION();
37660   }
37661
37662 }
37663
37664
37665 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
37666   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37667   Dali::TapGesture *arg2 = 0 ;
37668
37669   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37670   arg2 = (Dali::TapGesture *)jarg2;
37671   if (!arg2) {
37672     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
37673     return ;
37674   }
37675   {
37676     try {
37677       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
37678     } CALL_CATCH_EXCEPTION();
37679   }
37680
37681 }
37682
37683
37684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
37685   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37686   Dali::LongPressGesture *arg2 = 0 ;
37687
37688   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37689   arg2 = (Dali::LongPressGesture *)jarg2;
37690   if (!arg2) {
37691     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
37692     return ;
37693   }
37694   {
37695     try {
37696       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
37697     } CALL_CATCH_EXCEPTION();
37698   }
37699
37700 }
37701
37702
37703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
37704   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37705   Dali::LongPressGesture *arg2 = 0 ;
37706
37707   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37708   arg2 = (Dali::LongPressGesture *)jarg2;
37709   if (!arg2) {
37710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
37711     return ;
37712   }
37713   {
37714     try {
37715       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
37716     } CALL_CATCH_EXCEPTION();
37717   }
37718
37719 }
37720
37721
37722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
37723   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
37724   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
37725   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
37726
37727   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
37728   arg2 = (Dali::SlotObserver *)jarg2;
37729   arg3 = (Dali::CallbackBase *)jarg3;
37730   {
37731     try {
37732       (arg1)->SignalConnected(arg2,arg3);
37733     } CALL_CATCH_EXCEPTION();
37734   }
37735
37736 }
37737
37738
37739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(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)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
37750     } CALL_CATCH_EXCEPTION();
37751   }
37752
37753 }
37754
37755
37756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(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)->SignalDisconnected(arg2,arg3);
37767     } CALL_CATCH_EXCEPTION();
37768   }
37769
37770 }
37771
37772
37773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(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)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
37784     } CALL_CATCH_EXCEPTION();
37785   }
37786
37787 }
37788
37789 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) {
37790   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
37791   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
37792   if (director) {
37793     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);
37794   }
37795 }
37796
37797
37798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
37799   void * jresult ;
37800   Dali::Toolkit::Control *arg1 = 0 ;
37801   Dali::Toolkit::Internal::Control *result = 0 ;
37802
37803   arg1 = (Dali::Toolkit::Control *)jarg1;
37804   if (!arg1) {
37805     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
37806     return 0;
37807   }
37808   {
37809     try {
37810       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
37811     } CALL_CATCH_EXCEPTION(0);
37812   }
37813
37814   jresult = (void *)result;
37815   return jresult;
37816 }
37817
37818
37819 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
37820   int jresult ;
37821   int result;
37822
37823   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
37824   jresult = (int)result;
37825   return jresult;
37826 }
37827
37828 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
37829   int jresult ;
37830   int result;
37831
37832   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
37833   jresult = (int)result;
37834   return jresult;
37835 }
37836
37837
37838 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
37839   int jresult ;
37840   int result;
37841
37842   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
37843   jresult = (int)result;
37844   return jresult;
37845 }
37846
37847 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_MARGIN_get() {
37848   int jresult ;
37849   int result;
37850
37851   result = (int)Dali::Toolkit::Control::Property::MARGIN;
37852   jresult = (int)result;
37853   return jresult;
37854 }
37855
37856
37857 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_PADDING_get() {
37858   int jresult ;
37859   int result;
37860
37861   result = (int)Dali::Toolkit::Control::Property::PADDING;
37862   jresult = (int)result;
37863   return jresult;
37864 }
37865
37866 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_SHADOW_get() {
37867   int jresult ;
37868   int result;
37869
37870   result = (int)Dali::Toolkit::DevelControl::Property::SHADOW;
37871   jresult = (int)result;
37872   return jresult;
37873 }
37874
37875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
37876   void * jresult ;
37877   Dali::Toolkit::Control::Property *result = 0 ;
37878
37879   {
37880     try {
37881       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
37882     } CALL_CATCH_EXCEPTION(0);
37883   }
37884
37885   jresult = (void *)result;
37886   return jresult;
37887 }
37888
37889
37890 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
37891   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
37892
37893   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
37894   {
37895     try {
37896       delete arg1;
37897     } CALL_CATCH_EXCEPTION();
37898   }
37899
37900 }
37901
37902
37903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
37904   void * jresult ;
37905   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
37906
37907   {
37908     try {
37909       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
37910     } CALL_CATCH_EXCEPTION(0);
37911   }
37912
37913   jresult = (void *)result;
37914   return jresult;
37915 }
37916
37917
37918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
37919   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
37920
37921   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
37922   {
37923     try {
37924       delete arg1;
37925     } CALL_CATCH_EXCEPTION();
37926   }
37927
37928 }
37929
37930
37931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
37932   void * jresult ;
37933   Dali::Toolkit::Control result;
37934
37935   {
37936     try {
37937       result = Dali::Toolkit::Control::New();
37938     } CALL_CATCH_EXCEPTION(0);
37939   }
37940
37941   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
37942   return jresult;
37943 }
37944
37945
37946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
37947   void * jresult ;
37948   Dali::Toolkit::Control *result = 0 ;
37949
37950   {
37951     try {
37952       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
37953     } CALL_CATCH_EXCEPTION(0);
37954   }
37955
37956   jresult = (void *)result;
37957   return jresult;
37958 }
37959
37960
37961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
37962   void * jresult ;
37963   Dali::Toolkit::Control *arg1 = 0 ;
37964   Dali::Toolkit::Control *result = 0 ;
37965
37966   arg1 = (Dali::Toolkit::Control *)jarg1;
37967   if (!arg1) {
37968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
37969     return 0;
37970   }
37971   {
37972     try {
37973       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
37974     } CALL_CATCH_EXCEPTION(0);
37975   }
37976
37977   jresult = (void *)result;
37978   return jresult;
37979 }
37980
37981
37982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
37983   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
37984
37985   arg1 = (Dali::Toolkit::Control *)jarg1;
37986   {
37987     try {
37988       delete arg1;
37989     } CALL_CATCH_EXCEPTION();
37990   }
37991
37992 }
37993
37994
37995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
37996   void * jresult ;
37997   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
37998   Dali::Toolkit::Control *arg2 = 0 ;
37999   Dali::Toolkit::Control *result = 0 ;
38000
38001   arg1 = (Dali::Toolkit::Control *)jarg1;
38002   arg2 = (Dali::Toolkit::Control *)jarg2;
38003   if (!arg2) {
38004     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
38005     return 0;
38006   }
38007   {
38008     try {
38009       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
38010     } CALL_CATCH_EXCEPTION(0);
38011   }
38012
38013   jresult = (void *)result;
38014   return jresult;
38015 }
38016
38017
38018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
38019   void * jresult ;
38020   Dali::BaseHandle arg1 ;
38021   Dali::BaseHandle *argp1 ;
38022   Dali::Toolkit::Control result;
38023
38024   argp1 = (Dali::BaseHandle *)jarg1;
38025   if (!argp1) {
38026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
38027     return 0;
38028   }
38029   arg1 = *argp1;
38030   {
38031     try {
38032       result = Dali::Toolkit::Control::DownCast(arg1);
38033     } CALL_CATCH_EXCEPTION(0);
38034   }
38035
38036   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
38037   return jresult;
38038 }
38039
38040
38041 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
38042   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
38043
38044   arg1 = (Dali::Toolkit::Control *)jarg1;
38045   {
38046     try {
38047       (arg1)->SetKeyInputFocus();
38048     } CALL_CATCH_EXCEPTION();
38049   }
38050
38051 }
38052
38053
38054 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
38055   unsigned int jresult ;
38056   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
38057   bool result;
38058
38059   arg1 = (Dali::Toolkit::Control *)jarg1;
38060   {
38061     try {
38062       result = (bool)(arg1)->HasKeyInputFocus();
38063     } CALL_CATCH_EXCEPTION(0);
38064   }
38065
38066   jresult = result;
38067   return jresult;
38068 }
38069
38070
38071 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
38072   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
38073
38074   arg1 = (Dali::Toolkit::Control *)jarg1;
38075   {
38076     try {
38077       (arg1)->ClearKeyInputFocus();
38078     } CALL_CATCH_EXCEPTION();
38079   }
38080
38081 }
38082
38083
38084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
38085   void * jresult ;
38086   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
38087   Dali::PinchGestureDetector result;
38088
38089   arg1 = (Dali::Toolkit::Control *)jarg1;
38090   {
38091     try {
38092       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
38093     } CALL_CATCH_EXCEPTION(0);
38094   }
38095
38096   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
38097   return jresult;
38098 }
38099
38100
38101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
38102   void * jresult ;
38103   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
38104   Dali::PanGestureDetector result;
38105
38106   arg1 = (Dali::Toolkit::Control *)jarg1;
38107   {
38108     try {
38109       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
38110     } CALL_CATCH_EXCEPTION(0);
38111   }
38112
38113   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
38114   return jresult;
38115 }
38116
38117
38118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
38119   void * jresult ;
38120   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
38121   Dali::TapGestureDetector result;
38122
38123   arg1 = (Dali::Toolkit::Control *)jarg1;
38124   {
38125     try {
38126       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
38127     } CALL_CATCH_EXCEPTION(0);
38128   }
38129
38130   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
38131   return jresult;
38132 }
38133
38134
38135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
38136   void * jresult ;
38137   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
38138   Dali::LongPressGestureDetector result;
38139
38140   arg1 = (Dali::Toolkit::Control *)jarg1;
38141   {
38142     try {
38143       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
38144     } CALL_CATCH_EXCEPTION(0);
38145   }
38146
38147   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
38148   return jresult;
38149 }
38150
38151
38152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
38153   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
38154   std::string *arg2 = 0 ;
38155
38156   arg1 = (Dali::Toolkit::Control *)jarg1;
38157   if (!jarg2) {
38158     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
38159     return ;
38160   }
38161   std::string arg2_str(jarg2);
38162   arg2 = &arg2_str;
38163   {
38164     try {
38165       (arg1)->SetStyleName((std::string const &)*arg2);
38166     } CALL_CATCH_EXCEPTION();
38167   }
38168
38169
38170   //argout typemap for const std::string&
38171
38172 }
38173
38174
38175 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
38176   char * jresult ;
38177   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
38178   std::string *result = 0 ;
38179
38180   arg1 = (Dali::Toolkit::Control *)jarg1;
38181   {
38182     try {
38183       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
38184     } CALL_CATCH_EXCEPTION(0);
38185   }
38186
38187   jresult = SWIG_csharp_string_callback(result->c_str());
38188   return jresult;
38189 }
38190
38191
38192 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
38193   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
38194   Dali::Vector4 *arg2 = 0 ;
38195
38196   arg1 = (Dali::Toolkit::Control *)jarg1;
38197   arg2 = (Dali::Vector4 *)jarg2;
38198   if (!arg2) {
38199     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
38200     return ;
38201   }
38202   {
38203     try {
38204       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
38205     } CALL_CATCH_EXCEPTION();
38206   }
38207
38208 }
38209
38210 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
38211   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
38212
38213   arg1 = (Dali::Toolkit::Control *)jarg1;
38214   {
38215     try {
38216       (arg1)->ClearBackground();
38217     } CALL_CATCH_EXCEPTION();
38218   }
38219
38220 }
38221
38222
38223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyEventSignal(void * jarg1) {
38224   void * jresult ;
38225   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
38226   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
38227
38228   arg1 = (Dali::Toolkit::Control *)jarg1;
38229   {
38230     try {
38231       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
38232     } CALL_CATCH_EXCEPTION(0);
38233   }
38234
38235   jresult = (void *)result;
38236   return jresult;
38237 }
38238
38239
38240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
38241   void * jresult ;
38242   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
38243   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
38244
38245   arg1 = (Dali::Toolkit::Control *)jarg1;
38246   {
38247     try {
38248       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
38249     } CALL_CATCH_EXCEPTION(0);
38250   }
38251
38252   jresult = (void *)result;
38253   return jresult;
38254 }
38255
38256
38257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(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)->KeyInputFocusLostSignal();
38266     } CALL_CATCH_EXCEPTION(0);
38267   }
38268
38269   jresult = (void *)result;
38270   return jresult;
38271 }
38272
38273
38274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
38275   void * jresult ;
38276   Dali::Toolkit::Internal::Control *arg1 = 0 ;
38277   Dali::Toolkit::Control *result = 0 ;
38278
38279   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
38280   if (!arg1) {
38281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
38282     return 0;
38283   }
38284   {
38285     try {
38286       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
38287     } CALL_CATCH_EXCEPTION(0);
38288   }
38289
38290   jresult = (void *)result;
38291   return jresult;
38292 }
38293
38294 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_GetVisualResourceStatus(void * jarg1, int jarg2)
38295 {
38296   int jresult;
38297   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
38298   arg1 = (Dali::Toolkit::Control *)jarg1;
38299
38300   if (!arg1) {
38301     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
38302     return 0;
38303   }
38304
38305   Dali::Property::Index arg2 = 0 ;
38306   arg2 = (Dali::Property::Index)jarg2;
38307
38308   Toolkit::Visual::ResourceStatus result;
38309   {
38310     try {
38311       result = arg1->GetVisualResourceStatus(arg2);
38312     } CALL_CATCH_EXCEPTION(0);
38313   }
38314
38315   jresult = (int)result;
38316   return jresult;
38317 }
38318
38319 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_CreateTransition(void * jarg1, void * jarg2)
38320 {
38321   void * jresult;
38322   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
38323   arg1 = (Dali::Toolkit::Control *)jarg1;
38324
38325   Dali::Toolkit::Internal::Control& controlImpl = Dali::Toolkit::Internal::GetImplementation( *arg1 );
38326
38327   Dali::Toolkit::TransitionData *arg2 = 0 ;
38328   Dali::Animation result;
38329
38330   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
38331   if (!arg2) {
38332     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
38333     return 0;
38334   }
38335   {
38336     try {
38337       result = DevelControl::CreateTransition( controlImpl, (Dali::Toolkit::TransitionData const &)*arg2);
38338     } CALL_CATCH_EXCEPTION(0);
38339   }
38340
38341   jresult = new Dali::Animation((const Dali::Animation &)result);
38342   return jresult;
38343 }
38344
38345 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_DoAction(void * jarg1, int jarg2, int jarg3, void * jarg4 )
38346 {
38347   Dali::Toolkit::Control arg1;
38348   Dali::Toolkit::Control *argp1  = (Dali::Toolkit::Control *)jarg1;
38349
38350   if (!argp1) {
38351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
38352   }
38353   arg1 = *argp1;
38354
38355   Dali::Property::Index arg2 = 0 ;
38356   arg2 = (Dali::Property::Index)jarg2;
38357
38358   Dali::Property::Index arg3 = 0 ;
38359   arg3 = (Dali::Property::Index)jarg3;
38360
38361   Dali::Property::Value *arg4 = (Dali::Property::Value *)jarg4;
38362
38363   {
38364     try {
38365       DevelControl::DoAction(arg1, arg2, arg3, *arg4);
38366     } CALL_CATCH_EXCEPTION();
38367   }
38368 }
38369
38370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceReadySignal(void * jarg1) {
38371   void * jresult ;
38372   Dali::Toolkit::Control *arg1 = 0 ;
38373   Dali::Toolkit::Control::ResourceReadySignalType *result = 0 ;
38374
38375   arg1 = (Dali::Toolkit::Control *)jarg1;
38376   if (!arg1) {
38377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
38378     return 0;
38379   }
38380   {
38381     try {
38382       result = (Dali::Toolkit::Control::ResourceReadySignalType *) &arg1->ResourceReadySignal();
38383     } CALL_CATCH_EXCEPTION(0);
38384   }
38385
38386   jresult = (void *)result;
38387   return jresult;
38388 }
38389
38390
38391 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsResourceReady(void * jarg1) {
38392   unsigned int jresult ;
38393   Dali::Toolkit::Control *arg1 = 0 ;
38394   bool result;
38395
38396   arg1 = (Dali::Toolkit::Control *)jarg1;
38397   if (!arg1) {
38398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
38399     return 0;
38400   }
38401   {
38402     try {
38403       result = (bool)arg1->IsResourceReady();
38404     } CALL_CATCH_EXCEPTION(0);
38405   }
38406
38407   jresult = result;
38408   return jresult;
38409 }
38410
38411
38412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
38413   void * jresult ;
38414   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
38415
38416   {
38417     try {
38418       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
38419     } CALL_CATCH_EXCEPTION(0);
38420   }
38421
38422   jresult = (void *)result;
38423   return jresult;
38424 }
38425
38426
38427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
38428   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
38429
38430   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
38431   {
38432     try {
38433       delete arg1;
38434     } CALL_CATCH_EXCEPTION();
38435   }
38436
38437 }
38438
38439
38440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
38441   void * jresult ;
38442   Dali::Toolkit::KeyInputFocusManager result;
38443
38444   {
38445     try {
38446       result = Dali::Toolkit::KeyInputFocusManager::Get();
38447     } CALL_CATCH_EXCEPTION(0);
38448   }
38449
38450   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
38451   return jresult;
38452 }
38453
38454
38455 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
38456   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
38457   Dali::Toolkit::Control arg2 ;
38458   Dali::Toolkit::Control *argp2 ;
38459
38460   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
38461   argp2 = (Dali::Toolkit::Control *)jarg2;
38462   if (!argp2) {
38463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
38464     return ;
38465   }
38466   arg2 = *argp2;
38467   {
38468     try {
38469       (arg1)->SetFocus(arg2);
38470     } CALL_CATCH_EXCEPTION();
38471   }
38472
38473 }
38474
38475
38476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
38477   void * jresult ;
38478   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
38479   Dali::Toolkit::Control result;
38480
38481   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
38482   {
38483     try {
38484       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
38485     } CALL_CATCH_EXCEPTION(0);
38486   }
38487
38488   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
38489   return jresult;
38490 }
38491
38492
38493 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
38494   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
38495   Dali::Toolkit::Control arg2 ;
38496   Dali::Toolkit::Control *argp2 ;
38497
38498   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
38499   argp2 = (Dali::Toolkit::Control *)jarg2;
38500   if (!argp2) {
38501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
38502     return ;
38503   }
38504   arg2 = *argp2;
38505   {
38506     try {
38507       (arg1)->RemoveFocus(arg2);
38508     } CALL_CATCH_EXCEPTION();
38509   }
38510
38511 }
38512
38513
38514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
38515   void * jresult ;
38516   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
38517   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
38518
38519   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
38520   {
38521     try {
38522       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
38523     } CALL_CATCH_EXCEPTION(0);
38524   }
38525
38526   jresult = (void *)result;
38527   return jresult;
38528 }
38529
38530
38531 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
38532   void * jresult ;
38533   Dali::Toolkit::Alignment::Padding *result = 0 ;
38534
38535   {
38536     try {
38537       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
38538     } CALL_CATCH_EXCEPTION(0);
38539   }
38540
38541   jresult = (void *)result;
38542   return jresult;
38543 }
38544
38545
38546 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
38547   void * jresult ;
38548   float arg1 ;
38549   float arg2 ;
38550   float arg3 ;
38551   float arg4 ;
38552   Dali::Toolkit::Alignment::Padding *result = 0 ;
38553
38554   arg1 = (float)jarg1;
38555   arg2 = (float)jarg2;
38556   arg3 = (float)jarg3;
38557   arg4 = (float)jarg4;
38558   {
38559     try {
38560       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
38561     } CALL_CATCH_EXCEPTION(0);
38562   }
38563
38564   jresult = (void *)result;
38565   return jresult;
38566 }
38567
38568
38569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
38570   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
38571   float arg2 ;
38572
38573   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
38574   arg2 = (float)jarg2;
38575   if (arg1) (arg1)->left = arg2;
38576 }
38577
38578
38579 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
38580   float jresult ;
38581   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
38582   float result;
38583
38584   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
38585   result = (float) ((arg1)->left);
38586   jresult = result;
38587   return jresult;
38588 }
38589
38590
38591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
38592   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
38593   float arg2 ;
38594
38595   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
38596   arg2 = (float)jarg2;
38597   if (arg1) (arg1)->right = arg2;
38598 }
38599
38600
38601 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
38602   float jresult ;
38603   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
38604   float result;
38605
38606   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
38607   result = (float) ((arg1)->right);
38608   jresult = result;
38609   return jresult;
38610 }
38611
38612
38613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
38614   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
38615   float arg2 ;
38616
38617   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
38618   arg2 = (float)jarg2;
38619   if (arg1) (arg1)->top = arg2;
38620 }
38621
38622
38623 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
38624   float jresult ;
38625   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
38626   float result;
38627
38628   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
38629   result = (float) ((arg1)->top);
38630   jresult = result;
38631   return jresult;
38632 }
38633
38634
38635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
38636   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
38637   float arg2 ;
38638
38639   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
38640   arg2 = (float)jarg2;
38641   if (arg1) (arg1)->bottom = arg2;
38642 }
38643
38644
38645 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
38646   float jresult ;
38647   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
38648   float result;
38649
38650   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
38651   result = (float) ((arg1)->bottom);
38652   jresult = result;
38653   return jresult;
38654 }
38655
38656
38657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
38658   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
38659
38660   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
38661   {
38662     try {
38663       delete arg1;
38664     } CALL_CATCH_EXCEPTION();
38665   }
38666
38667 }
38668
38669
38670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
38671   void * jresult ;
38672   Dali::Toolkit::Alignment *result = 0 ;
38673
38674   {
38675     try {
38676       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
38677     } CALL_CATCH_EXCEPTION(0);
38678   }
38679
38680   jresult = (void *)result;
38681   return jresult;
38682 }
38683
38684
38685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
38686   void * jresult ;
38687   Dali::Toolkit::Alignment::Type arg1 ;
38688   Dali::Toolkit::Alignment::Type arg2 ;
38689   Dali::Toolkit::Alignment result;
38690
38691   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
38692   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
38693   {
38694     try {
38695       result = Dali::Toolkit::Alignment::New(arg1,arg2);
38696     } CALL_CATCH_EXCEPTION(0);
38697   }
38698
38699   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
38700   return jresult;
38701 }
38702
38703
38704 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
38705   void * jresult ;
38706   Dali::Toolkit::Alignment::Type arg1 ;
38707   Dali::Toolkit::Alignment result;
38708
38709   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
38710   {
38711     try {
38712       result = Dali::Toolkit::Alignment::New(arg1);
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_2() {
38722   void * jresult ;
38723   Dali::Toolkit::Alignment result;
38724
38725   {
38726     try {
38727       result = Dali::Toolkit::Alignment::New();
38728     } CALL_CATCH_EXCEPTION(0);
38729   }
38730
38731   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
38732   return jresult;
38733 }
38734
38735
38736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
38737   void * jresult ;
38738   Dali::Toolkit::Alignment *arg1 = 0 ;
38739   Dali::Toolkit::Alignment *result = 0 ;
38740
38741   arg1 = (Dali::Toolkit::Alignment *)jarg1;
38742   if (!arg1) {
38743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
38744     return 0;
38745   }
38746   {
38747     try {
38748       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
38749     } CALL_CATCH_EXCEPTION(0);
38750   }
38751
38752   jresult = (void *)result;
38753   return jresult;
38754 }
38755
38756
38757 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
38758   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
38759
38760   arg1 = (Dali::Toolkit::Alignment *)jarg1;
38761   {
38762     try {
38763       delete arg1;
38764     } CALL_CATCH_EXCEPTION();
38765   }
38766
38767 }
38768
38769
38770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
38771   void * jresult ;
38772   Dali::BaseHandle arg1 ;
38773   Dali::BaseHandle *argp1 ;
38774   Dali::Toolkit::Alignment result;
38775
38776   argp1 = (Dali::BaseHandle *)jarg1;
38777   if (!argp1) {
38778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
38779     return 0;
38780   }
38781   arg1 = *argp1;
38782   {
38783     try {
38784       result = Dali::Toolkit::Alignment::DownCast(arg1);
38785     } CALL_CATCH_EXCEPTION(0);
38786   }
38787
38788   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
38789   return jresult;
38790 }
38791
38792
38793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
38794   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
38795   Dali::Toolkit::Alignment::Type arg2 ;
38796
38797   arg1 = (Dali::Toolkit::Alignment *)jarg1;
38798   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
38799   {
38800     try {
38801       (arg1)->SetAlignmentType(arg2);
38802     } CALL_CATCH_EXCEPTION();
38803   }
38804
38805 }
38806
38807
38808 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
38809   int jresult ;
38810   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
38811   Dali::Toolkit::Alignment::Type result;
38812
38813   arg1 = (Dali::Toolkit::Alignment *)jarg1;
38814   {
38815     try {
38816       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
38817     } CALL_CATCH_EXCEPTION(0);
38818   }
38819
38820   jresult = (int)result;
38821   return jresult;
38822 }
38823
38824
38825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
38826   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
38827   Dali::Toolkit::Alignment::Scaling arg2 ;
38828
38829   arg1 = (Dali::Toolkit::Alignment *)jarg1;
38830   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
38831   {
38832     try {
38833       (arg1)->SetScaling(arg2);
38834     } CALL_CATCH_EXCEPTION();
38835   }
38836
38837 }
38838
38839
38840 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
38841   int jresult ;
38842   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
38843   Dali::Toolkit::Alignment::Scaling result;
38844
38845   arg1 = (Dali::Toolkit::Alignment *)jarg1;
38846   {
38847     try {
38848       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
38849     } CALL_CATCH_EXCEPTION(0);
38850   }
38851
38852   jresult = (int)result;
38853   return jresult;
38854 }
38855
38856
38857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
38858   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
38859   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
38860
38861   arg1 = (Dali::Toolkit::Alignment *)jarg1;
38862   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
38863   if (!arg2) {
38864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
38865     return ;
38866   }
38867   {
38868     try {
38869       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
38870     } CALL_CATCH_EXCEPTION();
38871   }
38872
38873 }
38874
38875
38876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
38877   void * jresult ;
38878   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
38879   Dali::Toolkit::Alignment::Padding *result = 0 ;
38880
38881   arg1 = (Dali::Toolkit::Alignment *)jarg1;
38882   {
38883     try {
38884       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
38885     } CALL_CATCH_EXCEPTION(0);
38886   }
38887
38888   jresult = (void *)result;
38889   return jresult;
38890 }
38891
38892
38893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
38894   void * jresult ;
38895   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
38896   Dali::Toolkit::Alignment *arg2 = 0 ;
38897   Dali::Toolkit::Alignment *result = 0 ;
38898
38899   arg1 = (Dali::Toolkit::Alignment *)jarg1;
38900   arg2 = (Dali::Toolkit::Alignment *)jarg2;
38901   if (!arg2) {
38902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
38903     return 0;
38904   }
38905   {
38906     try {
38907       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
38908     } CALL_CATCH_EXCEPTION(0);
38909   }
38910
38911   jresult = (void *)result;
38912   return jresult;
38913 }
38914
38915
38916 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
38917   int jresult ;
38918   int result;
38919
38920   result = (int)Dali::Toolkit::Button::Property::DISABLED;
38921   jresult = (int)result;
38922   return jresult;
38923 }
38924
38925
38926 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
38927   int jresult ;
38928   int result;
38929
38930   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
38931   jresult = (int)result;
38932   return jresult;
38933 }
38934
38935
38936 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
38937   int jresult ;
38938   int result;
38939
38940   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
38941   jresult = (int)result;
38942   return jresult;
38943 }
38944
38945
38946 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
38947   int jresult ;
38948   int result;
38949
38950   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
38951   jresult = (int)result;
38952   return jresult;
38953 }
38954
38955
38956 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
38957   int jresult ;
38958   int result;
38959
38960   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
38961   jresult = (int)result;
38962   return jresult;
38963 }
38964
38965
38966 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
38967   int jresult ;
38968   int result;
38969
38970   result = (int)Dali::Toolkit::Button::Property::SELECTED;
38971   jresult = (int)result;
38972   return jresult;
38973 }
38974
38975 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
38976   int jresult ;
38977   int result;
38978
38979   result = (int)Dali::Toolkit::Button::Property::LABEL;
38980   jresult = (int)result;
38981   return jresult;
38982 }
38983
38984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
38985   void * jresult ;
38986   Dali::Toolkit::Button::Property *result = 0 ;
38987
38988   {
38989     try {
38990       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
38991     } CALL_CATCH_EXCEPTION(0);
38992   }
38993
38994   jresult = (void *)result;
38995   return jresult;
38996 }
38997
38998
38999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
39000   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
39001
39002   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
39003   {
39004     try {
39005       delete arg1;
39006     } CALL_CATCH_EXCEPTION();
39007   }
39008
39009 }
39010
39011
39012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
39013   void * jresult ;
39014   Dali::Toolkit::Button *result = 0 ;
39015
39016   {
39017     try {
39018       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
39019     } CALL_CATCH_EXCEPTION(0);
39020   }
39021
39022   jresult = (void *)result;
39023   return jresult;
39024 }
39025
39026
39027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
39028   void * jresult ;
39029   Dali::Toolkit::Button *arg1 = 0 ;
39030   Dali::Toolkit::Button *result = 0 ;
39031
39032   arg1 = (Dali::Toolkit::Button *)jarg1;
39033   if (!arg1) {
39034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
39035     return 0;
39036   }
39037   {
39038     try {
39039       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
39040     } CALL_CATCH_EXCEPTION(0);
39041   }
39042
39043   jresult = (void *)result;
39044   return jresult;
39045 }
39046
39047
39048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
39049   void * jresult ;
39050   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
39051   Dali::Toolkit::Button *arg2 = 0 ;
39052   Dali::Toolkit::Button *result = 0 ;
39053
39054   arg1 = (Dali::Toolkit::Button *)jarg1;
39055   arg2 = (Dali::Toolkit::Button *)jarg2;
39056   if (!arg2) {
39057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
39058     return 0;
39059   }
39060   {
39061     try {
39062       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
39063     } CALL_CATCH_EXCEPTION(0);
39064   }
39065
39066   jresult = (void *)result;
39067   return jresult;
39068 }
39069
39070
39071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
39072   void * jresult ;
39073   Dali::BaseHandle arg1 ;
39074   Dali::BaseHandle *argp1 ;
39075   Dali::Toolkit::Button result;
39076
39077   argp1 = (Dali::BaseHandle *)jarg1;
39078   if (!argp1) {
39079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
39080     return 0;
39081   }
39082   arg1 = *argp1;
39083   {
39084     try {
39085       result = Dali::Toolkit::Button::DownCast(arg1);
39086     } CALL_CATCH_EXCEPTION(0);
39087   }
39088
39089   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
39090   return jresult;
39091 }
39092
39093
39094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
39095   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
39096
39097   arg1 = (Dali::Toolkit::Button *)jarg1;
39098   {
39099     try {
39100       delete arg1;
39101     } CALL_CATCH_EXCEPTION();
39102   }
39103
39104 }
39105
39106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
39107   void * jresult ;
39108   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
39109   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
39110
39111   arg1 = (Dali::Toolkit::Button *)jarg1;
39112   {
39113     try {
39114       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
39115     } CALL_CATCH_EXCEPTION(0);
39116   }
39117
39118   jresult = (void *)result;
39119   return jresult;
39120 }
39121
39122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
39123   void * jresult ;
39124   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
39125   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
39126
39127   arg1 = (Dali::Toolkit::Button *)jarg1;
39128   {
39129     try {
39130       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
39131     } CALL_CATCH_EXCEPTION(0);
39132   }
39133
39134   jresult = (void *)result;
39135   return jresult;
39136 }
39137
39138
39139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(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)->ClickedSignal();
39148     } CALL_CATCH_EXCEPTION(0);
39149   }
39150
39151   jresult = (void *)result;
39152   return jresult;
39153 }
39154
39155
39156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(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)->StateChangedSignal();
39165     } CALL_CATCH_EXCEPTION(0);
39166   }
39167
39168   jresult = (void *)result;
39169   return jresult;
39170 }
39171
39172
39173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
39174   void * jresult ;
39175   Dali::Toolkit::CheckBoxButton *result = 0 ;
39176
39177   {
39178     try {
39179       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
39180     } CALL_CATCH_EXCEPTION(0);
39181   }
39182
39183   jresult = (void *)result;
39184   return jresult;
39185 }
39186
39187
39188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
39189   void * jresult ;
39190   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
39191   Dali::Toolkit::CheckBoxButton *result = 0 ;
39192
39193   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
39194   if (!arg1) {
39195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
39196     return 0;
39197   }
39198   {
39199     try {
39200       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
39201     } CALL_CATCH_EXCEPTION(0);
39202   }
39203
39204   jresult = (void *)result;
39205   return jresult;
39206 }
39207
39208
39209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
39210   void * jresult ;
39211   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
39212   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
39213   Dali::Toolkit::CheckBoxButton *result = 0 ;
39214
39215   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
39216   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
39217   if (!arg2) {
39218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
39219     return 0;
39220   }
39221   {
39222     try {
39223       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
39224     } CALL_CATCH_EXCEPTION(0);
39225   }
39226
39227   jresult = (void *)result;
39228   return jresult;
39229 }
39230
39231
39232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
39233   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
39234
39235   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
39236   {
39237     try {
39238       delete arg1;
39239     } CALL_CATCH_EXCEPTION();
39240   }
39241
39242 }
39243
39244
39245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
39246   void * jresult ;
39247   Dali::Toolkit::CheckBoxButton result;
39248
39249   {
39250     try {
39251       result = Dali::Toolkit::CheckBoxButton::New();
39252     } CALL_CATCH_EXCEPTION(0);
39253   }
39254
39255   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
39256   return jresult;
39257 }
39258
39259
39260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
39261   void * jresult ;
39262   Dali::BaseHandle arg1 ;
39263   Dali::BaseHandle *argp1 ;
39264   Dali::Toolkit::CheckBoxButton result;
39265
39266   argp1 = (Dali::BaseHandle *)jarg1;
39267   if (!argp1) {
39268     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
39269     return 0;
39270   }
39271   arg1 = *argp1;
39272   {
39273     try {
39274       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
39275     } CALL_CATCH_EXCEPTION(0);
39276   }
39277
39278   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
39279   return jresult;
39280 }
39281
39282
39283 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
39284   int jresult ;
39285   int result;
39286
39287   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
39288   jresult = (int)result;
39289   return jresult;
39290 }
39291
39292
39293 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
39294   int jresult ;
39295   int result;
39296
39297   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
39298   jresult = (int)result;
39299   return jresult;
39300 }
39301
39302
39303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
39304   void * jresult ;
39305   Dali::Toolkit::PushButton::Property *result = 0 ;
39306
39307   {
39308     try {
39309       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
39310     } CALL_CATCH_EXCEPTION(0);
39311   }
39312
39313   jresult = (void *)result;
39314   return jresult;
39315 }
39316
39317
39318 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
39319   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
39320
39321   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
39322   {
39323     try {
39324       delete arg1;
39325     } CALL_CATCH_EXCEPTION();
39326   }
39327
39328 }
39329
39330
39331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
39332   void * jresult ;
39333   Dali::Toolkit::PushButton *result = 0 ;
39334
39335   {
39336     try {
39337       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
39338     } CALL_CATCH_EXCEPTION(0);
39339   }
39340
39341   jresult = (void *)result;
39342   return jresult;
39343 }
39344
39345
39346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
39347   void * jresult ;
39348   Dali::Toolkit::PushButton *arg1 = 0 ;
39349   Dali::Toolkit::PushButton *result = 0 ;
39350
39351   arg1 = (Dali::Toolkit::PushButton *)jarg1;
39352   if (!arg1) {
39353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
39354     return 0;
39355   }
39356   {
39357     try {
39358       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
39359     } CALL_CATCH_EXCEPTION(0);
39360   }
39361
39362   jresult = (void *)result;
39363   return jresult;
39364 }
39365
39366
39367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
39368   void * jresult ;
39369   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
39370   Dali::Toolkit::PushButton *arg2 = 0 ;
39371   Dali::Toolkit::PushButton *result = 0 ;
39372
39373   arg1 = (Dali::Toolkit::PushButton *)jarg1;
39374   arg2 = (Dali::Toolkit::PushButton *)jarg2;
39375   if (!arg2) {
39376     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
39377     return 0;
39378   }
39379   {
39380     try {
39381       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
39382     } CALL_CATCH_EXCEPTION(0);
39383   }
39384
39385   jresult = (void *)result;
39386   return jresult;
39387 }
39388
39389
39390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
39391   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
39392
39393   arg1 = (Dali::Toolkit::PushButton *)jarg1;
39394   {
39395     try {
39396       delete arg1;
39397     } CALL_CATCH_EXCEPTION();
39398   }
39399
39400 }
39401
39402
39403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
39404   void * jresult ;
39405   Dali::Toolkit::PushButton result;
39406
39407   {
39408     try {
39409       result = Dali::Toolkit::PushButton::New();
39410     } CALL_CATCH_EXCEPTION(0);
39411   }
39412
39413   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
39414   return jresult;
39415 }
39416
39417
39418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
39419   void * jresult ;
39420   Dali::BaseHandle arg1 ;
39421   Dali::BaseHandle *argp1 ;
39422   Dali::Toolkit::PushButton result;
39423
39424   argp1 = (Dali::BaseHandle *)jarg1;
39425   if (!argp1) {
39426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
39427     return 0;
39428   }
39429   arg1 = *argp1;
39430   {
39431     try {
39432       result = Dali::Toolkit::PushButton::DownCast(arg1);
39433     } CALL_CATCH_EXCEPTION(0);
39434   }
39435
39436   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
39437   return jresult;
39438 }
39439
39440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
39441   void * jresult ;
39442   Dali::Toolkit::RadioButton *result = 0 ;
39443
39444   {
39445     try {
39446       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
39447     } CALL_CATCH_EXCEPTION(0);
39448   }
39449
39450   jresult = (void *)result;
39451   return jresult;
39452 }
39453
39454
39455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
39456   void * jresult ;
39457   Dali::Toolkit::RadioButton *arg1 = 0 ;
39458   Dali::Toolkit::RadioButton *result = 0 ;
39459
39460   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
39461   if (!arg1) {
39462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
39463     return 0;
39464   }
39465   {
39466     try {
39467       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
39468     } CALL_CATCH_EXCEPTION(0);
39469   }
39470
39471   jresult = (void *)result;
39472   return jresult;
39473 }
39474
39475
39476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
39477   void * jresult ;
39478   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
39479   Dali::Toolkit::RadioButton *arg2 = 0 ;
39480   Dali::Toolkit::RadioButton *result = 0 ;
39481
39482   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
39483   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
39484   if (!arg2) {
39485     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
39486     return 0;
39487   }
39488   {
39489     try {
39490       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
39491     } CALL_CATCH_EXCEPTION(0);
39492   }
39493
39494   jresult = (void *)result;
39495   return jresult;
39496 }
39497
39498
39499 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
39500   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
39501
39502   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
39503   {
39504     try {
39505       delete arg1;
39506     } CALL_CATCH_EXCEPTION();
39507   }
39508
39509 }
39510
39511
39512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
39513   void * jresult ;
39514   Dali::Toolkit::RadioButton result;
39515
39516   {
39517     try {
39518       result = Dali::Toolkit::RadioButton::New();
39519     } CALL_CATCH_EXCEPTION(0);
39520   }
39521
39522   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
39523   return jresult;
39524 }
39525
39526
39527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
39528   void * jresult ;
39529   std::string *arg1 = 0 ;
39530   Dali::Toolkit::RadioButton result;
39531
39532   if (!jarg1) {
39533     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
39534     return 0;
39535   }
39536   std::string arg1_str(jarg1);
39537   arg1 = &arg1_str;
39538   {
39539     try {
39540       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
39541     } CALL_CATCH_EXCEPTION(0);
39542   }
39543
39544   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
39545
39546   //argout typemap for const std::string&
39547
39548   return jresult;
39549 }
39550
39551
39552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
39553   void * jresult ;
39554   Dali::BaseHandle arg1 ;
39555   Dali::BaseHandle *argp1 ;
39556   Dali::Toolkit::RadioButton result;
39557
39558   argp1 = (Dali::BaseHandle *)jarg1;
39559   if (!argp1) {
39560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
39561     return 0;
39562   }
39563   arg1 = *argp1;
39564   {
39565     try {
39566       result = Dali::Toolkit::RadioButton::DownCast(arg1);
39567     } CALL_CATCH_EXCEPTION(0);
39568   }
39569
39570   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
39571   return jresult;
39572 }
39573
39574
39575 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
39576   int jresult ;
39577   int result;
39578
39579   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
39580   jresult = (int)result;
39581   return jresult;
39582 }
39583
39584
39585 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
39586   int jresult ;
39587   int result;
39588
39589   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
39590   jresult = (int)result;
39591   return jresult;
39592 }
39593
39594
39595 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
39596   int jresult ;
39597   int result;
39598
39599   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
39600   jresult = (int)result;
39601   return jresult;
39602 }
39603
39604
39605 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
39606   int jresult ;
39607   int result;
39608
39609   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
39610   jresult = (int)result;
39611   return jresult;
39612 }
39613
39614
39615 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
39616   int jresult ;
39617   int result;
39618
39619   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
39620   jresult = (int)result;
39621   return jresult;
39622 }
39623
39624
39625 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
39626   int jresult ;
39627   int result;
39628
39629   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
39630   jresult = (int)result;
39631   return jresult;
39632 }
39633
39634
39635 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
39636   void * jresult ;
39637   Dali::Toolkit::FlexContainer::Property *result = 0 ;
39638
39639   {
39640     try {
39641       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
39642     } CALL_CATCH_EXCEPTION(0);
39643   }
39644
39645   jresult = (void *)result;
39646   return jresult;
39647 }
39648
39649
39650 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
39651   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
39652
39653   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
39654   {
39655     try {
39656       delete arg1;
39657     } CALL_CATCH_EXCEPTION();
39658   }
39659
39660 }
39661
39662
39663 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
39664   int jresult ;
39665   int result;
39666
39667   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
39668   jresult = (int)result;
39669   return jresult;
39670 }
39671
39672
39673 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
39674   int jresult ;
39675   int result;
39676
39677   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
39678   jresult = (int)result;
39679   return jresult;
39680 }
39681
39682
39683 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
39684   int jresult ;
39685   int result;
39686
39687   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
39688   jresult = (int)result;
39689   return jresult;
39690 }
39691
39692
39693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
39694   void * jresult ;
39695   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
39696
39697   {
39698     try {
39699       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
39700     } CALL_CATCH_EXCEPTION(0);
39701   }
39702
39703   jresult = (void *)result;
39704   return jresult;
39705 }
39706
39707
39708 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
39709   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
39710
39711   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
39712   {
39713     try {
39714       delete arg1;
39715     } CALL_CATCH_EXCEPTION();
39716   }
39717
39718 }
39719
39720
39721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
39722   void * jresult ;
39723   Dali::Toolkit::FlexContainer *result = 0 ;
39724
39725   {
39726     try {
39727       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
39728     } CALL_CATCH_EXCEPTION(0);
39729   }
39730
39731   jresult = (void *)result;
39732   return jresult;
39733 }
39734
39735
39736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
39737   void * jresult ;
39738   Dali::Toolkit::FlexContainer *arg1 = 0 ;
39739   Dali::Toolkit::FlexContainer *result = 0 ;
39740
39741   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
39742   if (!arg1) {
39743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
39744     return 0;
39745   }
39746   {
39747     try {
39748       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
39749     } CALL_CATCH_EXCEPTION(0);
39750   }
39751
39752   jresult = (void *)result;
39753   return jresult;
39754 }
39755
39756
39757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
39758   void * jresult ;
39759   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
39760   Dali::Toolkit::FlexContainer *arg2 = 0 ;
39761   Dali::Toolkit::FlexContainer *result = 0 ;
39762
39763   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
39764   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
39765   if (!arg2) {
39766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
39767     return 0;
39768   }
39769   {
39770     try {
39771       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
39772     } CALL_CATCH_EXCEPTION(0);
39773   }
39774
39775   jresult = (void *)result;
39776   return jresult;
39777 }
39778
39779
39780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
39781   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
39782
39783   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
39784   {
39785     try {
39786       delete arg1;
39787     } CALL_CATCH_EXCEPTION();
39788   }
39789
39790 }
39791
39792
39793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
39794   void * jresult ;
39795   Dali::Toolkit::FlexContainer result;
39796
39797   {
39798     try {
39799       result = Dali::Toolkit::FlexContainer::New();
39800     } CALL_CATCH_EXCEPTION(0);
39801   }
39802
39803   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
39804   return jresult;
39805 }
39806
39807
39808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
39809   void * jresult ;
39810   Dali::BaseHandle arg1 ;
39811   Dali::BaseHandle *argp1 ;
39812   Dali::Toolkit::FlexContainer result;
39813
39814   argp1 = (Dali::BaseHandle *)jarg1;
39815   if (!argp1) {
39816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
39817     return 0;
39818   }
39819   arg1 = *argp1;
39820   {
39821     try {
39822       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
39823     } CALL_CATCH_EXCEPTION(0);
39824   }
39825
39826   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
39827   return jresult;
39828 }
39829
39830 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
39831   int jresult ;
39832   int result;
39833
39834   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
39835   jresult = (int)result;
39836   return jresult;
39837 }
39838
39839
39840 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
39841   int jresult ;
39842   int result;
39843
39844   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
39845   jresult = (int)result;
39846   return jresult;
39847 }
39848
39849
39850 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
39851   int jresult ;
39852   int result;
39853
39854   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
39855   jresult = (int)result;
39856   return jresult;
39857 }
39858
39859
39860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
39861   void * jresult ;
39862   Dali::Toolkit::ImageView::Property *result = 0 ;
39863
39864   {
39865     try {
39866       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
39867     } CALL_CATCH_EXCEPTION(0);
39868   }
39869
39870   jresult = (void *)result;
39871   return jresult;
39872 }
39873
39874
39875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
39876   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
39877
39878   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
39879   {
39880     try {
39881       delete arg1;
39882     } CALL_CATCH_EXCEPTION();
39883   }
39884
39885 }
39886
39887
39888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
39889   void * jresult ;
39890   Dali::Toolkit::ImageView *result = 0 ;
39891
39892   {
39893     try {
39894       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
39895     } CALL_CATCH_EXCEPTION(0);
39896   }
39897
39898   jresult = (void *)result;
39899   return jresult;
39900 }
39901
39902
39903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
39904   void * jresult ;
39905   Dali::Toolkit::ImageView result;
39906
39907   {
39908     try {
39909       result = Dali::Toolkit::ImageView::New();
39910     } CALL_CATCH_EXCEPTION(0);
39911   }
39912
39913   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
39914   return jresult;
39915 }
39916
39917
39918 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
39919   void * jresult ;
39920   std::string *arg1 = 0 ;
39921   Dali::Toolkit::ImageView result;
39922
39923   if (!jarg1) {
39924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
39925     return 0;
39926   }
39927   std::string arg1_str(jarg1);
39928   arg1 = &arg1_str;
39929   {
39930     try {
39931       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
39932     } CALL_CATCH_EXCEPTION(0);
39933   }
39934
39935   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
39936
39937   //argout typemap for const std::string&
39938
39939   return jresult;
39940 }
39941
39942
39943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
39944   void * jresult ;
39945   std::string *arg1 = 0 ;
39946   Dali::ImageDimensions arg2 ;
39947   Dali::ImageDimensions *argp2 ;
39948   Dali::Toolkit::ImageView result;
39949
39950   if (!jarg1) {
39951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
39952     return 0;
39953   }
39954   std::string arg1_str(jarg1);
39955   arg1 = &arg1_str;
39956   argp2 = (Dali::ImageDimensions *)jarg2;
39957   if (!argp2) {
39958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
39959     return 0;
39960   }
39961   arg2 = *argp2;
39962   {
39963     try {
39964       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
39965     } CALL_CATCH_EXCEPTION(0);
39966   }
39967
39968   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
39969
39970   //argout typemap for const std::string&
39971
39972   return jresult;
39973 }
39974
39975
39976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
39977   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
39978
39979   arg1 = (Dali::Toolkit::ImageView *)jarg1;
39980   {
39981     try {
39982       delete arg1;
39983     } CALL_CATCH_EXCEPTION();
39984   }
39985
39986 }
39987
39988
39989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
39990   void * jresult ;
39991   Dali::Toolkit::ImageView *arg1 = 0 ;
39992   Dali::Toolkit::ImageView *result = 0 ;
39993
39994   arg1 = (Dali::Toolkit::ImageView *)jarg1;
39995   if (!arg1) {
39996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
39997     return 0;
39998   }
39999   {
40000     try {
40001       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
40002     } CALL_CATCH_EXCEPTION(0);
40003   }
40004
40005   jresult = (void *)result;
40006   return jresult;
40007 }
40008
40009
40010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
40011   void * jresult ;
40012   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
40013   Dali::Toolkit::ImageView *arg2 = 0 ;
40014   Dali::Toolkit::ImageView *result = 0 ;
40015
40016   arg1 = (Dali::Toolkit::ImageView *)jarg1;
40017   arg2 = (Dali::Toolkit::ImageView *)jarg2;
40018   if (!arg2) {
40019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
40020     return 0;
40021   }
40022   {
40023     try {
40024       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
40025     } CALL_CATCH_EXCEPTION(0);
40026   }
40027
40028   jresult = (void *)result;
40029   return jresult;
40030 }
40031
40032
40033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
40034   void * jresult ;
40035   Dali::BaseHandle arg1 ;
40036   Dali::BaseHandle *argp1 ;
40037   Dali::Toolkit::ImageView result;
40038
40039   argp1 = (Dali::BaseHandle *)jarg1;
40040   if (!argp1) {
40041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40042     return 0;
40043   }
40044   arg1 = *argp1;
40045   {
40046     try {
40047       result = Dali::Toolkit::ImageView::DownCast(arg1);
40048     } CALL_CATCH_EXCEPTION(0);
40049   }
40050
40051   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
40052   return jresult;
40053 }
40054
40055
40056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
40057   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
40058   std::string *arg2 = 0 ;
40059
40060   arg1 = (Dali::Toolkit::ImageView *)jarg1;
40061   if (!jarg2) {
40062     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
40063     return ;
40064   }
40065   std::string arg2_str(jarg2);
40066   arg2 = &arg2_str;
40067   {
40068     try {
40069       (arg1)->SetImage((std::string const &)*arg2);
40070     } CALL_CATCH_EXCEPTION();
40071   }
40072
40073
40074   //argout typemap for const std::string&
40075
40076 }
40077
40078
40079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
40080   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
40081   std::string *arg2 = 0 ;
40082   Dali::ImageDimensions arg3 ;
40083   Dali::ImageDimensions *argp3 ;
40084
40085   arg1 = (Dali::Toolkit::ImageView *)jarg1;
40086   if (!jarg2) {
40087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
40088     return ;
40089   }
40090   std::string arg2_str(jarg2);
40091   arg2 = &arg2_str;
40092   argp3 = (Dali::ImageDimensions *)jarg3;
40093   if (!argp3) {
40094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
40095     return ;
40096   }
40097   arg3 = *argp3;
40098   {
40099     try {
40100       (arg1)->SetImage((std::string const &)*arg2,arg3);
40101     } CALL_CATCH_EXCEPTION();
40102   }
40103
40104
40105   //argout typemap for const std::string&
40106
40107 }
40108
40109
40110 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_GEOMETRY_URL_get() {
40111   int jresult ;
40112   int result;
40113
40114   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
40115   jresult = (int)result;
40116   return jresult;
40117 }
40118
40119
40120 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_MATERIAL_URL_get() {
40121   int jresult ;
40122   int result;
40123
40124   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
40125   jresult = (int)result;
40126   return jresult;
40127 }
40128
40129
40130 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_IMAGES_URL_get() {
40131   int jresult ;
40132   int result;
40133
40134   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
40135   jresult = (int)result;
40136   return jresult;
40137 }
40138
40139
40140 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_ILLUMINATION_TYPE_get() {
40141   int jresult ;
40142   int result;
40143
40144   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
40145   jresult = (int)result;
40146   return jresult;
40147 }
40148
40149
40150 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE0_URL_get() {
40151   int jresult ;
40152   int result;
40153
40154   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
40155   jresult = (int)result;
40156   return jresult;
40157 }
40158
40159
40160 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE1_URL_get() {
40161   int jresult ;
40162   int result;
40163
40164   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
40165   jresult = (int)result;
40166   return jresult;
40167 }
40168
40169
40170 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE2_URL_get() {
40171   int jresult ;
40172   int result;
40173
40174   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
40175   jresult = (int)result;
40176   return jresult;
40177 }
40178
40179
40180 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_LIGHT_POSITION_get() {
40181   int jresult ;
40182   int result;
40183
40184   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
40185   jresult = (int)result;
40186   return jresult;
40187 }
40188
40189
40190 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView_Property() {
40191   void * jresult ;
40192   Dali::Toolkit::Model3dView::Property *result = 0 ;
40193
40194   {
40195     try {
40196       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
40197     } CALL_CATCH_EXCEPTION(0);
40198   }
40199
40200   jresult = (void *)result;
40201   return jresult;
40202 }
40203
40204
40205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView_Property(void * jarg1) {
40206   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
40207
40208   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
40209   {
40210     try {
40211       delete arg1;
40212     } CALL_CATCH_EXCEPTION();
40213   }
40214
40215 }
40216
40217
40218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_0() {
40219   void * jresult ;
40220   Dali::Toolkit::Model3dView result;
40221
40222   {
40223     try {
40224       result = Dali::Toolkit::Model3dView::New();
40225     } CALL_CATCH_EXCEPTION(0);
40226   }
40227
40228   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
40229   return jresult;
40230 }
40231
40232
40233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
40234   void * jresult ;
40235   std::string *arg1 = 0 ;
40236   std::string *arg2 = 0 ;
40237   std::string *arg3 = 0 ;
40238   Dali::Toolkit::Model3dView result;
40239
40240   if (!jarg1) {
40241     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
40242     return 0;
40243   }
40244   std::string arg1_str(jarg1);
40245   arg1 = &arg1_str;
40246   if (!jarg2) {
40247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
40248     return 0;
40249   }
40250   std::string arg2_str(jarg2);
40251   arg2 = &arg2_str;
40252   if (!jarg3) {
40253     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
40254     return 0;
40255   }
40256   std::string arg3_str(jarg3);
40257   arg3 = &arg3_str;
40258   {
40259     try {
40260       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
40261     } CALL_CATCH_EXCEPTION(0);
40262   }
40263
40264   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
40265
40266   //argout typemap for const std::string&
40267
40268
40269   //argout typemap for const std::string&
40270
40271
40272   //argout typemap for const std::string&
40273
40274   return jresult;
40275 }
40276
40277
40278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_0() {
40279   void * jresult ;
40280   Dali::Toolkit::Model3dView *result = 0 ;
40281
40282   {
40283     try {
40284       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
40285     } CALL_CATCH_EXCEPTION(0);
40286   }
40287
40288   jresult = (void *)result;
40289   return jresult;
40290 }
40291
40292
40293 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView(void * jarg1) {
40294   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
40295
40296   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
40297   {
40298     try {
40299       delete arg1;
40300     } CALL_CATCH_EXCEPTION();
40301   }
40302
40303 }
40304
40305
40306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_1(void * jarg1) {
40307   void * jresult ;
40308   Dali::Toolkit::Model3dView *arg1 = 0 ;
40309   Dali::Toolkit::Model3dView *result = 0 ;
40310
40311   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
40312   if (!arg1) {
40313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
40314     return 0;
40315   }
40316   {
40317     try {
40318       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
40319     } CALL_CATCH_EXCEPTION(0);
40320   }
40321
40322   jresult = (void *)result;
40323   return jresult;
40324 }
40325
40326
40327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_Assign(void * jarg1, void * jarg2) {
40328   void * jresult ;
40329   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
40330   Dali::Toolkit::Model3dView *arg2 = 0 ;
40331   Dali::Toolkit::Model3dView *result = 0 ;
40332
40333   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
40334   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
40335   if (!arg2) {
40336     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
40337     return 0;
40338   }
40339   {
40340     try {
40341       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
40342     } CALL_CATCH_EXCEPTION(0);
40343   }
40344
40345   jresult = (void *)result;
40346   return jresult;
40347 }
40348
40349
40350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_DownCast(void * jarg1) {
40351   void * jresult ;
40352   Dali::BaseHandle arg1 ;
40353   Dali::BaseHandle *argp1 ;
40354   Dali::Toolkit::Model3dView result;
40355
40356   argp1 = (Dali::BaseHandle *)jarg1;
40357   if (!argp1) {
40358     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40359     return 0;
40360   }
40361   arg1 = *argp1;
40362   {
40363     try {
40364       result = Dali::Toolkit::Model3dView::DownCast(arg1);
40365     } CALL_CATCH_EXCEPTION(0);
40366   }
40367
40368   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
40369   return jresult;
40370 }
40371
40372
40373 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
40374   int jresult ;
40375   int result;
40376
40377   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
40378   jresult = (int)result;
40379   return jresult;
40380 }
40381
40382
40383 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
40384   int jresult ;
40385   int result;
40386
40387   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
40388   jresult = (int)result;
40389   return jresult;
40390 }
40391
40392
40393 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
40394   int jresult ;
40395   int result;
40396
40397   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
40398   jresult = (int)result;
40399   return jresult;
40400 }
40401
40402
40403 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
40404   int jresult ;
40405   int result;
40406
40407   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
40408   jresult = (int)result;
40409   return jresult;
40410 }
40411
40412
40413 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
40414   int jresult ;
40415   int result;
40416
40417   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
40418   jresult = (int)result;
40419   return jresult;
40420 }
40421
40422
40423 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
40424   int jresult ;
40425   int result;
40426
40427   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
40428   jresult = (int)result;
40429   return jresult;
40430 }
40431
40432
40433 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
40434   int jresult ;
40435   int result;
40436
40437   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
40438   jresult = (int)result;
40439   return jresult;
40440 }
40441
40442
40443 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
40444   int jresult ;
40445   int result;
40446
40447   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
40448   jresult = (int)result;
40449   return jresult;
40450 }
40451
40452
40453 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
40454   int jresult ;
40455   int result;
40456
40457   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
40458   jresult = (int)result;
40459   return jresult;
40460 }
40461
40462
40463 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
40464   void * jresult ;
40465   Dali::Toolkit::ScrollBar::Property *result = 0 ;
40466
40467   {
40468     try {
40469       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
40470     } CALL_CATCH_EXCEPTION(0);
40471   }
40472
40473   jresult = (void *)result;
40474   return jresult;
40475 }
40476
40477
40478 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
40479   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
40480
40481   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
40482   {
40483     try {
40484       delete arg1;
40485     } CALL_CATCH_EXCEPTION();
40486   }
40487
40488 }
40489
40490
40491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
40492   void * jresult ;
40493   Dali::Toolkit::ScrollBar *result = 0 ;
40494
40495   {
40496     try {
40497       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
40498     } CALL_CATCH_EXCEPTION(0);
40499   }
40500
40501   jresult = (void *)result;
40502   return jresult;
40503 }
40504
40505
40506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
40507   void * jresult ;
40508   Dali::Toolkit::ScrollBar *arg1 = 0 ;
40509   Dali::Toolkit::ScrollBar *result = 0 ;
40510
40511   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40512   if (!arg1) {
40513     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
40514     return 0;
40515   }
40516   {
40517     try {
40518       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
40519     } CALL_CATCH_EXCEPTION(0);
40520   }
40521
40522   jresult = (void *)result;
40523   return jresult;
40524 }
40525
40526
40527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
40528   void * jresult ;
40529   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40530   Dali::Toolkit::ScrollBar *arg2 = 0 ;
40531   Dali::Toolkit::ScrollBar *result = 0 ;
40532
40533   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40534   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
40535   if (!arg2) {
40536     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
40537     return 0;
40538   }
40539   {
40540     try {
40541       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
40542     } CALL_CATCH_EXCEPTION(0);
40543   }
40544
40545   jresult = (void *)result;
40546   return jresult;
40547 }
40548
40549
40550 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
40551   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40552
40553   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40554   {
40555     try {
40556       delete arg1;
40557     } CALL_CATCH_EXCEPTION();
40558   }
40559
40560 }
40561
40562
40563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
40564   void * jresult ;
40565   Dali::Toolkit::ScrollBar::Direction arg1 ;
40566   Dali::Toolkit::ScrollBar result;
40567
40568   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
40569   {
40570     try {
40571       result = Dali::Toolkit::ScrollBar::New(arg1);
40572     } CALL_CATCH_EXCEPTION(0);
40573   }
40574
40575   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
40576   return jresult;
40577 }
40578
40579
40580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
40581   void * jresult ;
40582   Dali::Toolkit::ScrollBar result;
40583
40584   {
40585     try {
40586       result = Dali::Toolkit::ScrollBar::New();
40587     } CALL_CATCH_EXCEPTION(0);
40588   }
40589
40590   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
40591   return jresult;
40592 }
40593
40594
40595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
40596   void * jresult ;
40597   Dali::BaseHandle arg1 ;
40598   Dali::BaseHandle *argp1 ;
40599   Dali::Toolkit::ScrollBar result;
40600
40601   argp1 = (Dali::BaseHandle *)jarg1;
40602   if (!argp1) {
40603     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40604     return 0;
40605   }
40606   arg1 = *argp1;
40607   {
40608     try {
40609       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
40610     } CALL_CATCH_EXCEPTION(0);
40611   }
40612
40613   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
40614   return jresult;
40615 }
40616
40617
40618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
40619   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40620   Dali::Handle arg2 ;
40621   Dali::Property::Index arg3 ;
40622   Dali::Property::Index arg4 ;
40623   Dali::Property::Index arg5 ;
40624   Dali::Property::Index arg6 ;
40625   Dali::Handle *argp2 ;
40626
40627   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40628   argp2 = (Dali::Handle *)jarg2;
40629   if (!argp2) {
40630     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
40631     return ;
40632   }
40633   arg2 = *argp2;
40634   arg3 = (Dali::Property::Index)jarg3;
40635   arg4 = (Dali::Property::Index)jarg4;
40636   arg5 = (Dali::Property::Index)jarg5;
40637   arg6 = (Dali::Property::Index)jarg6;
40638   {
40639     try {
40640       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
40641     } CALL_CATCH_EXCEPTION();
40642   }
40643
40644 }
40645
40646
40647 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
40648   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40649   Dali::Actor arg2 ;
40650   Dali::Actor *argp2 ;
40651
40652   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40653   argp2 = (Dali::Actor *)jarg2;
40654   if (!argp2) {
40655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40656     return ;
40657   }
40658   arg2 = *argp2;
40659   {
40660     try {
40661       (arg1)->SetScrollIndicator(arg2);
40662     } CALL_CATCH_EXCEPTION();
40663   }
40664
40665 }
40666
40667
40668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
40669   void * jresult ;
40670   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40671   Dali::Actor result;
40672
40673   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40674   {
40675     try {
40676       result = (arg1)->GetScrollIndicator();
40677     } CALL_CATCH_EXCEPTION(0);
40678   }
40679
40680   jresult = new Dali::Actor((const Dali::Actor &)result);
40681   return jresult;
40682 }
40683
40684
40685 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
40686   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40687   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
40688
40689   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40690   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
40691   if (!arg2) {
40692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
40693     return ;
40694   }
40695   {
40696     try {
40697       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
40698     } CALL_CATCH_EXCEPTION();
40699   }
40700
40701 }
40702
40703
40704 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
40705   void * jresult ;
40706   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40707
40708   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40709   {
40710     try {
40711       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()));
40712     } CALL_CATCH_EXCEPTION(0);
40713   }
40714   return jresult;
40715 }
40716
40717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
40718   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40719   Dali::Toolkit::ScrollBar::Direction arg2 ;
40720
40721   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40722   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
40723   {
40724     try {
40725       (arg1)->SetScrollDirection(arg2);
40726     } CALL_CATCH_EXCEPTION();
40727   }
40728
40729 }
40730
40731
40732 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
40733   int jresult ;
40734   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40735   Dali::Toolkit::ScrollBar::Direction result;
40736
40737   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40738   {
40739     try {
40740       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
40741     } CALL_CATCH_EXCEPTION(0);
40742   }
40743
40744   jresult = (int)result;
40745   return jresult;
40746 }
40747
40748
40749 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
40750   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40751   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
40752
40753   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40754   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
40755   {
40756     try {
40757       (arg1)->SetIndicatorHeightPolicy(arg2);
40758     } CALL_CATCH_EXCEPTION();
40759   }
40760
40761 }
40762
40763
40764 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
40765   int jresult ;
40766   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40767   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
40768
40769   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40770   {
40771     try {
40772       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
40773     } CALL_CATCH_EXCEPTION(0);
40774   }
40775
40776   jresult = (int)result;
40777   return jresult;
40778 }
40779
40780
40781 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
40782   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40783   float arg2 ;
40784
40785   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40786   arg2 = (float)jarg2;
40787   {
40788     try {
40789       (arg1)->SetIndicatorFixedHeight(arg2);
40790     } CALL_CATCH_EXCEPTION();
40791   }
40792
40793 }
40794
40795
40796 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
40797   float jresult ;
40798   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40799   float result;
40800
40801   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40802   {
40803     try {
40804       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
40805     } CALL_CATCH_EXCEPTION(0);
40806   }
40807
40808   jresult = result;
40809   return jresult;
40810 }
40811
40812
40813 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
40814   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40815   float arg2 ;
40816
40817   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40818   arg2 = (float)jarg2;
40819   {
40820     try {
40821       (arg1)->SetIndicatorShowDuration(arg2);
40822     } CALL_CATCH_EXCEPTION();
40823   }
40824
40825 }
40826
40827
40828 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
40829   float jresult ;
40830   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40831   float result;
40832
40833   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40834   {
40835     try {
40836       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
40837     } CALL_CATCH_EXCEPTION(0);
40838   }
40839
40840   jresult = result;
40841   return jresult;
40842 }
40843
40844
40845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
40846   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40847   float arg2 ;
40848
40849   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40850   arg2 = (float)jarg2;
40851   {
40852     try {
40853       (arg1)->SetIndicatorHideDuration(arg2);
40854     } CALL_CATCH_EXCEPTION();
40855   }
40856
40857 }
40858
40859
40860 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
40861   float jresult ;
40862   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40863   float result;
40864
40865   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40866   {
40867     try {
40868       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
40869     } CALL_CATCH_EXCEPTION(0);
40870   }
40871
40872   jresult = result;
40873   return jresult;
40874 }
40875
40876
40877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
40878   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40879
40880   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40881   {
40882     try {
40883       (arg1)->ShowIndicator();
40884     } CALL_CATCH_EXCEPTION();
40885   }
40886
40887 }
40888
40889
40890 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
40891   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40892
40893   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40894   {
40895     try {
40896       (arg1)->HideIndicator();
40897     } CALL_CATCH_EXCEPTION();
40898   }
40899
40900 }
40901
40902
40903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
40904   void * jresult ;
40905   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40906   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
40907
40908   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40909   {
40910     try {
40911       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
40912     } CALL_CATCH_EXCEPTION(0);
40913   }
40914
40915   jresult = (void *)result;
40916   return jresult;
40917 }
40918
40919
40920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
40921   void * jresult ;
40922   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
40923   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
40924
40925   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
40926   {
40927     try {
40928       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
40929     } CALL_CATCH_EXCEPTION(0);
40930   }
40931
40932   jresult = (void *)result;
40933   return jresult;
40934 }
40935
40936
40937 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
40938   int jresult ;
40939   int result;
40940
40941   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
40942   jresult = (int)result;
40943   return jresult;
40944 }
40945
40946
40947 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
40948   int jresult ;
40949   int result;
40950
40951   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
40952   jresult = (int)result;
40953   return jresult;
40954 }
40955
40956
40957 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
40958   int jresult ;
40959   int result;
40960
40961   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
40962   jresult = (int)result;
40963   return jresult;
40964 }
40965
40966
40967 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
40968   int jresult ;
40969   int result;
40970
40971   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
40972   jresult = (int)result;
40973   return jresult;
40974 }
40975
40976
40977 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
40978   int jresult ;
40979   int result;
40980
40981   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
40982   jresult = (int)result;
40983   return jresult;
40984 }
40985
40986
40987 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
40988   int jresult ;
40989   int result;
40990
40991   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
40992   jresult = (int)result;
40993   return jresult;
40994 }
40995
40996
40997 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
40998   int jresult ;
40999   int result;
41000
41001   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
41002   jresult = (int)result;
41003   return jresult;
41004 }
41005
41006
41007 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
41008   int jresult ;
41009   int result;
41010
41011   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
41012   jresult = (int)result;
41013   return jresult;
41014 }
41015
41016
41017 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
41018   int jresult ;
41019   int result;
41020
41021   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
41022   jresult = (int)result;
41023   return jresult;
41024 }
41025
41026
41027 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
41028   int jresult ;
41029   int result;
41030
41031   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
41032   jresult = (int)result;
41033   return jresult;
41034 }
41035
41036
41037 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
41038   int jresult ;
41039   int result;
41040
41041   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
41042   jresult = (int)result;
41043   return jresult;
41044 }
41045
41046
41047 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
41048   int jresult ;
41049   int result;
41050
41051   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
41052   jresult = (int)result;
41053   return jresult;
41054 }
41055
41056
41057 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
41058   int jresult ;
41059   int result;
41060
41061   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
41062   jresult = (int)result;
41063   return jresult;
41064 }
41065
41066
41067 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
41068   int jresult ;
41069   int result;
41070
41071   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
41072   jresult = (int)result;
41073   return jresult;
41074 }
41075
41076
41077 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
41078   void * jresult ;
41079   Dali::Toolkit::Scrollable::Property *result = 0 ;
41080
41081   {
41082     try {
41083       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
41084     } CALL_CATCH_EXCEPTION(0);
41085   }
41086
41087   jresult = (void *)result;
41088   return jresult;
41089 }
41090
41091
41092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
41093   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
41094
41095   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
41096   {
41097     try {
41098       delete arg1;
41099     } CALL_CATCH_EXCEPTION();
41100   }
41101
41102 }
41103
41104
41105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
41106   void * jresult ;
41107   Dali::Toolkit::Scrollable *result = 0 ;
41108
41109   {
41110     try {
41111       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
41112     } CALL_CATCH_EXCEPTION(0);
41113   }
41114
41115   jresult = (void *)result;
41116   return jresult;
41117 }
41118
41119
41120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
41121   void * jresult ;
41122   Dali::Toolkit::Scrollable *arg1 = 0 ;
41123   Dali::Toolkit::Scrollable *result = 0 ;
41124
41125   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
41126   if (!arg1) {
41127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
41128     return 0;
41129   }
41130   {
41131     try {
41132       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
41133     } CALL_CATCH_EXCEPTION(0);
41134   }
41135
41136   jresult = (void *)result;
41137   return jresult;
41138 }
41139
41140
41141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
41142   void * jresult ;
41143   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
41144   Dali::Toolkit::Scrollable *arg2 = 0 ;
41145   Dali::Toolkit::Scrollable *result = 0 ;
41146
41147   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
41148   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
41149   if (!arg2) {
41150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
41151     return 0;
41152   }
41153   {
41154     try {
41155       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
41156     } CALL_CATCH_EXCEPTION(0);
41157   }
41158
41159   jresult = (void *)result;
41160   return jresult;
41161 }
41162
41163
41164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
41165   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
41166
41167   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
41168   {
41169     try {
41170       delete arg1;
41171     } CALL_CATCH_EXCEPTION();
41172   }
41173
41174 }
41175
41176
41177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
41178   void * jresult ;
41179   Dali::BaseHandle arg1 ;
41180   Dali::BaseHandle *argp1 ;
41181   Dali::Toolkit::Scrollable result;
41182
41183   argp1 = (Dali::BaseHandle *)jarg1;
41184   if (!argp1) {
41185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41186     return 0;
41187   }
41188   arg1 = *argp1;
41189   {
41190     try {
41191       result = Dali::Toolkit::Scrollable::DownCast(arg1);
41192     } CALL_CATCH_EXCEPTION(0);
41193   }
41194
41195   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
41196   return jresult;
41197 }
41198
41199
41200 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
41201   unsigned int jresult ;
41202   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
41203   bool result;
41204
41205   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
41206   {
41207     try {
41208       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
41209     } CALL_CATCH_EXCEPTION(0);
41210   }
41211
41212   jresult = result;
41213   return jresult;
41214 }
41215
41216
41217 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
41218   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
41219   bool arg2 ;
41220
41221   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
41222   arg2 = jarg2 ? true : false;
41223   {
41224     try {
41225       (arg1)->SetOvershootEnabled(arg2);
41226     } CALL_CATCH_EXCEPTION();
41227   }
41228
41229 }
41230
41231
41232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
41233   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
41234   Dali::Vector4 *arg2 = 0 ;
41235
41236   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
41237   arg2 = (Dali::Vector4 *)jarg2;
41238   if (!arg2) {
41239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
41240     return ;
41241   }
41242   {
41243     try {
41244       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
41245     } CALL_CATCH_EXCEPTION();
41246   }
41247
41248 }
41249
41250
41251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
41252   void * jresult ;
41253   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
41254   Dali::Vector4 result;
41255
41256   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
41257   {
41258     try {
41259       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
41260     } CALL_CATCH_EXCEPTION(0);
41261   }
41262
41263   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
41264   return jresult;
41265 }
41266
41267
41268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
41269   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
41270   float arg2 ;
41271
41272   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
41273   arg2 = (float)jarg2;
41274   {
41275     try {
41276       (arg1)->SetOvershootAnimationSpeed(arg2);
41277     } CALL_CATCH_EXCEPTION();
41278   }
41279
41280 }
41281
41282
41283 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
41284   float jresult ;
41285   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
41286   float result;
41287
41288   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
41289   {
41290     try {
41291       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
41292     } CALL_CATCH_EXCEPTION(0);
41293   }
41294
41295   jresult = result;
41296   return jresult;
41297 }
41298
41299
41300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
41301   void * jresult ;
41302   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
41303   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
41304
41305   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
41306   {
41307     try {
41308       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
41309     } CALL_CATCH_EXCEPTION(0);
41310   }
41311
41312   jresult = (void *)result;
41313   return jresult;
41314 }
41315
41316
41317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
41318   void * jresult ;
41319   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
41320   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
41321
41322   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
41323   {
41324     try {
41325       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
41326     } CALL_CATCH_EXCEPTION(0);
41327   }
41328
41329   jresult = (void *)result;
41330   return jresult;
41331 }
41332
41333
41334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
41335   void * jresult ;
41336   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
41337   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
41338
41339   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
41340   {
41341     try {
41342       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
41343     } CALL_CATCH_EXCEPTION(0);
41344   }
41345
41346   jresult = (void *)result;
41347   return jresult;
41348 }
41349
41350
41351 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
41352   unsigned int jresult ;
41353   Dali::Toolkit::ControlOrientation::Type arg1 ;
41354   bool result;
41355
41356   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
41357   {
41358     try {
41359       result = (bool)Dali::Toolkit::IsVertical(arg1);
41360     } CALL_CATCH_EXCEPTION(0);
41361   }
41362
41363   jresult = result;
41364   return jresult;
41365 }
41366
41367
41368 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsHorizontal(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::IsHorizontal(arg1);
41377     } CALL_CATCH_EXCEPTION(0);
41378   }
41379
41380   jresult = result;
41381   return jresult;
41382 }
41383
41384
41385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
41386   void * jresult ;
41387   unsigned int arg1 ;
41388   unsigned int arg2 ;
41389   Dali::Toolkit::ItemRange *result = 0 ;
41390
41391   arg1 = (unsigned int)jarg1;
41392   arg2 = (unsigned int)jarg2;
41393   {
41394     try {
41395       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
41396     } CALL_CATCH_EXCEPTION(0);
41397   }
41398
41399   jresult = (void *)result;
41400   return jresult;
41401 }
41402
41403
41404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
41405   void * jresult ;
41406   Dali::Toolkit::ItemRange *arg1 = 0 ;
41407   Dali::Toolkit::ItemRange *result = 0 ;
41408
41409   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
41410   if (!arg1) {
41411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
41412     return 0;
41413   }
41414   {
41415     try {
41416       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
41417     } CALL_CATCH_EXCEPTION(0);
41418   }
41419
41420   jresult = (void *)result;
41421   return jresult;
41422 }
41423
41424
41425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
41426   void * jresult ;
41427   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
41428   Dali::Toolkit::ItemRange *arg2 = 0 ;
41429   Dali::Toolkit::ItemRange *result = 0 ;
41430
41431   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
41432   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
41433   if (!arg2) {
41434     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
41435     return 0;
41436   }
41437   {
41438     try {
41439       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
41440     } CALL_CATCH_EXCEPTION(0);
41441   }
41442
41443   jresult = (void *)result;
41444   return jresult;
41445 }
41446
41447
41448 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
41449   unsigned int jresult ;
41450   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
41451   unsigned int arg2 ;
41452   bool result;
41453
41454   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
41455   arg2 = (unsigned int)jarg2;
41456   {
41457     try {
41458       result = (bool)(arg1)->Within(arg2);
41459     } CALL_CATCH_EXCEPTION(0);
41460   }
41461
41462   jresult = result;
41463   return jresult;
41464 }
41465
41466
41467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
41468   void * jresult ;
41469   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
41470   Dali::Toolkit::ItemRange *arg2 = 0 ;
41471   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
41472
41473   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
41474   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
41475   if (!arg2) {
41476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
41477     return 0;
41478   }
41479   {
41480     try {
41481       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
41482     } CALL_CATCH_EXCEPTION(0);
41483   }
41484
41485   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
41486   return jresult;
41487 }
41488
41489
41490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
41491   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
41492   unsigned int arg2 ;
41493
41494   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
41495   arg2 = (unsigned int)jarg2;
41496   if (arg1) (arg1)->begin = arg2;
41497 }
41498
41499
41500 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
41501   unsigned int jresult ;
41502   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
41503   unsigned int result;
41504
41505   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
41506   result = (unsigned int) ((arg1)->begin);
41507   jresult = result;
41508   return jresult;
41509 }
41510
41511
41512 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
41513   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
41514   unsigned int arg2 ;
41515
41516   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
41517   arg2 = (unsigned int)jarg2;
41518   if (arg1) (arg1)->end = arg2;
41519 }
41520
41521
41522 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
41523   unsigned int jresult ;
41524   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
41525   unsigned int result;
41526
41527   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
41528   result = (unsigned int) ((arg1)->end);
41529   jresult = result;
41530   return jresult;
41531 }
41532
41533
41534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
41535   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
41536
41537   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
41538   {
41539     try {
41540       delete arg1;
41541     } CALL_CATCH_EXCEPTION();
41542   }
41543
41544 }
41545
41546
41547 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
41548   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41549
41550   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41551   {
41552     try {
41553       delete arg1;
41554     } CALL_CATCH_EXCEPTION();
41555   }
41556
41557 }
41558
41559
41560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
41561   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41562   Dali::Toolkit::ControlOrientation::Type arg2 ;
41563
41564   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41565   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
41566   {
41567     try {
41568       (arg1)->SetOrientation(arg2);
41569     } CALL_CATCH_EXCEPTION();
41570   }
41571
41572 }
41573
41574
41575 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
41576   int jresult ;
41577   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41578   Dali::Toolkit::ControlOrientation::Type result;
41579
41580   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41581   {
41582     try {
41583       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
41584     } CALL_CATCH_EXCEPTION(0);
41585   }
41586
41587   jresult = (int)result;
41588   return jresult;
41589 }
41590
41591
41592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
41593   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41594   Dali::Property::Map *arg2 = 0 ;
41595
41596   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41597   arg2 = (Dali::Property::Map *)jarg2;
41598   if (!arg2) {
41599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
41600     return ;
41601   }
41602   {
41603     try {
41604       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
41605     } CALL_CATCH_EXCEPTION();
41606   }
41607
41608 }
41609
41610
41611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
41612   void * jresult ;
41613   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41614   Dali::Property::Map result;
41615
41616   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41617   {
41618     try {
41619       result = (arg1)->GetLayoutProperties();
41620     } CALL_CATCH_EXCEPTION(0);
41621   }
41622
41623   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
41624   return jresult;
41625 }
41626
41627
41628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
41629   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41630   unsigned int arg2 ;
41631   Dali::Vector3 *arg3 = 0 ;
41632   Dali::Vector3 *arg4 = 0 ;
41633
41634   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41635   arg2 = (unsigned int)jarg2;
41636   arg3 = (Dali::Vector3 *)jarg3;
41637   if (!arg3) {
41638     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
41639     return ;
41640   }
41641   arg4 = (Dali::Vector3 *)jarg4;
41642   if (!arg4) {
41643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
41644     return ;
41645   }
41646   {
41647     try {
41648       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
41649     } CALL_CATCH_EXCEPTION();
41650   }
41651
41652 }
41653
41654
41655 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
41656   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41657   Dali::Vector3 *arg2 = 0 ;
41658
41659   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41660   arg2 = (Dali::Vector3 *)jarg2;
41661   if (!arg2) {
41662     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
41663     return ;
41664   }
41665   {
41666     try {
41667       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
41668     } CALL_CATCH_EXCEPTION();
41669   }
41670
41671 }
41672
41673
41674 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
41675   float jresult ;
41676   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41677   unsigned int arg2 ;
41678   Dali::Vector3 arg3 ;
41679   Dali::Vector3 *argp3 ;
41680   float result;
41681
41682   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41683   arg2 = (unsigned int)jarg2;
41684   argp3 = (Dali::Vector3 *)jarg3;
41685   if (!argp3) {
41686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
41687     return 0;
41688   }
41689   arg3 = *argp3;
41690   {
41691     try {
41692       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
41693     } CALL_CATCH_EXCEPTION(0);
41694   }
41695
41696   jresult = result;
41697   return jresult;
41698 }
41699
41700
41701 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
41702   float jresult ;
41703   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41704   float arg2 ;
41705   float result;
41706
41707   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41708   arg2 = (float)jarg2;
41709   {
41710     try {
41711       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
41712     } CALL_CATCH_EXCEPTION(0);
41713   }
41714
41715   jresult = result;
41716   return jresult;
41717 }
41718
41719
41720 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
41721   float jresult ;
41722   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41723   unsigned int arg2 ;
41724   float result;
41725
41726   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41727   arg2 = (unsigned int)jarg2;
41728   {
41729     try {
41730       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
41731     } CALL_CATCH_EXCEPTION(0);
41732   }
41733
41734   jresult = result;
41735   return jresult;
41736 }
41737
41738
41739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
41740   void * jresult ;
41741   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41742   float arg2 ;
41743   Dali::Vector3 arg3 ;
41744   Dali::Vector3 *argp3 ;
41745   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
41746
41747   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41748   arg2 = (float)jarg2;
41749   argp3 = (Dali::Vector3 *)jarg3;
41750   if (!argp3) {
41751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
41752     return 0;
41753   }
41754   arg3 = *argp3;
41755   {
41756     try {
41757       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
41758     } CALL_CATCH_EXCEPTION(0);
41759   }
41760
41761   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
41762   return jresult;
41763 }
41764
41765
41766 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
41767   float jresult ;
41768   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41769   int arg2 ;
41770   float arg3 ;
41771   Dali::Vector3 *arg4 = 0 ;
41772   float result;
41773
41774   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41775   arg2 = (int)jarg2;
41776   arg3 = (float)jarg3;
41777   arg4 = (Dali::Vector3 *)jarg4;
41778   if (!arg4) {
41779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
41780     return 0;
41781   }
41782   {
41783     try {
41784       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
41785     } CALL_CATCH_EXCEPTION(0);
41786   }
41787
41788   jresult = result;
41789   return jresult;
41790 }
41791
41792
41793 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
41794   unsigned int jresult ;
41795   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41796   Dali::Vector3 arg2 ;
41797   Dali::Vector3 *argp2 ;
41798   unsigned int result;
41799
41800   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41801   argp2 = (Dali::Vector3 *)jarg2;
41802   if (!argp2) {
41803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
41804     return 0;
41805   }
41806   arg2 = *argp2;
41807   {
41808     try {
41809       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
41810     } CALL_CATCH_EXCEPTION(0);
41811   }
41812
41813   jresult = result;
41814   return jresult;
41815 }
41816
41817
41818 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
41819   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41820   unsigned int arg2 ;
41821   Dali::Vector3 *arg3 = 0 ;
41822   Dali::Vector3 *arg4 = 0 ;
41823
41824   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41825   arg2 = (unsigned int)jarg2;
41826   arg3 = (Dali::Vector3 *)jarg3;
41827   if (!arg3) {
41828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
41829     return ;
41830   }
41831   arg4 = (Dali::Vector3 *)jarg4;
41832   if (!arg4) {
41833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
41834     return ;
41835   }
41836   {
41837     try {
41838       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
41839     } CALL_CATCH_EXCEPTION();
41840   }
41841
41842 }
41843
41844
41845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
41846   void * jresult ;
41847   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41848   Dali::Degree result;
41849
41850   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41851   {
41852     try {
41853       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
41854     } CALL_CATCH_EXCEPTION(0);
41855   }
41856
41857   jresult = new Dali::Degree((const Dali::Degree &)result);
41858   return jresult;
41859 }
41860
41861
41862 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
41863   float jresult ;
41864   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41865   float result;
41866
41867   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41868   {
41869     try {
41870       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
41871     } CALL_CATCH_EXCEPTION(0);
41872   }
41873
41874   jresult = result;
41875   return jresult;
41876 }
41877
41878
41879 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(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)->GetMaximumSwipeSpeed();
41888     } CALL_CATCH_EXCEPTION(0);
41889   }
41890
41891   jresult = result;
41892   return jresult;
41893 }
41894
41895
41896 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(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)->GetItemFlickAnimationDuration();
41905     } CALL_CATCH_EXCEPTION(0);
41906   }
41907
41908   jresult = result;
41909   return jresult;
41910 }
41911
41912
41913 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
41914   int jresult ;
41915   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41916   int arg2 ;
41917   int arg3 ;
41918   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
41919   bool arg5 ;
41920   int result;
41921
41922   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41923   arg2 = (int)jarg2;
41924   arg3 = (int)jarg3;
41925   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
41926   arg5 = jarg5 ? true : false;
41927   {
41928     try {
41929       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
41930     } CALL_CATCH_EXCEPTION(0);
41931   }
41932
41933   jresult = result;
41934   return jresult;
41935 }
41936
41937
41938 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
41939   float jresult ;
41940   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41941   float result;
41942
41943   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41944   {
41945     try {
41946       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
41947     } CALL_CATCH_EXCEPTION(0);
41948   }
41949
41950   jresult = result;
41951   return jresult;
41952 }
41953
41954
41955 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
41956   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41957   Dali::Actor *arg2 = 0 ;
41958   int arg3 ;
41959   Dali::Vector3 *arg4 = 0 ;
41960   Dali::Actor *arg5 = 0 ;
41961
41962   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41963   arg2 = (Dali::Actor *)jarg2;
41964   if (!arg2) {
41965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
41966     return ;
41967   }
41968   arg3 = (int)jarg3;
41969   arg4 = (Dali::Vector3 *)jarg4;
41970   if (!arg4) {
41971     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
41972     return ;
41973   }
41974   arg5 = (Dali::Actor *)jarg5;
41975   if (!arg5) {
41976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
41977     return ;
41978   }
41979   {
41980     try {
41981       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
41982     } CALL_CATCH_EXCEPTION();
41983   }
41984
41985 }
41986
41987
41988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
41989   void * jresult ;
41990   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
41991   int arg2 ;
41992   float arg3 ;
41993   Dali::Vector3 *arg4 = 0 ;
41994   Dali::Vector3 result;
41995
41996   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
41997   arg2 = (int)jarg2;
41998   arg3 = (float)jarg3;
41999   arg4 = (Dali::Vector3 *)jarg4;
42000   if (!arg4) {
42001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
42002     return 0;
42003   }
42004   {
42005     try {
42006       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
42007     } CALL_CATCH_EXCEPTION(0);
42008   }
42009
42010   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
42011   return jresult;
42012 }
42013
42014
42015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
42016   void * jresult ;
42017   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
42018   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
42019
42020   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
42021   {
42022     try {
42023       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
42024     } CALL_CATCH_EXCEPTION(0);
42025   }
42026
42027   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
42028   return jresult;
42029 }
42030
42031
42032 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
42033   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
42034
42035   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
42036   {
42037     try {
42038       delete arg1;
42039     } CALL_CATCH_EXCEPTION();
42040   }
42041
42042 }
42043
42044
42045 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
42046   unsigned int jresult ;
42047   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
42048   unsigned int result;
42049
42050   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
42051   {
42052     try {
42053       result = (unsigned int)(arg1)->GetNumberOfItems();
42054     } CALL_CATCH_EXCEPTION(0);
42055   }
42056
42057   jresult = result;
42058   return jresult;
42059 }
42060
42061
42062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
42063   void * jresult ;
42064   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
42065   unsigned int arg2 ;
42066   Dali::Actor result;
42067
42068   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
42069   arg2 = (unsigned int)jarg2;
42070   {
42071     try {
42072       result = (arg1)->NewItem(arg2);
42073     } CALL_CATCH_EXCEPTION(0);
42074   }
42075
42076   jresult = new Dali::Actor((const Dali::Actor &)result);
42077   return jresult;
42078 }
42079
42080
42081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
42082   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
42083   unsigned int arg2 ;
42084   Dali::Actor arg3 ;
42085   Dali::Actor *argp3 ;
42086
42087   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
42088   arg2 = (unsigned int)jarg2;
42089   argp3 = (Dali::Actor *)jarg3;
42090   if (!argp3) {
42091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
42092     return ;
42093   }
42094   arg3 = *argp3;
42095   {
42096     try {
42097       (arg1)->ItemReleased(arg2,arg3);
42098     } CALL_CATCH_EXCEPTION();
42099   }
42100
42101 }
42102
42103
42104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
42105   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
42106   unsigned int arg2 ;
42107   Dali::Actor arg3 ;
42108   Dali::Actor *argp3 ;
42109
42110   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
42111   arg2 = (unsigned int)jarg2;
42112   argp3 = (Dali::Actor *)jarg3;
42113   if (!argp3) {
42114     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
42115     return ;
42116   }
42117   arg3 = *argp3;
42118   {
42119     try {
42120       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
42121     } CALL_CATCH_EXCEPTION();
42122   }
42123
42124 }
42125
42126
42127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
42128   void * jresult ;
42129   Dali::Toolkit::ItemFactory *result = 0 ;
42130
42131   {
42132     try {
42133       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
42134     } CALL_CATCH_EXCEPTION(0);
42135   }
42136
42137   jresult = (void *)result;
42138   return jresult;
42139 }
42140
42141
42142 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) {
42143   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
42144   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
42145   if (director) {
42146     director->swig_connect_director(callback0, callback1, callback2);
42147   }
42148 }
42149
42150
42151 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
42152   int jresult ;
42153   int result;
42154
42155   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
42156   jresult = (int)result;
42157   return jresult;
42158 }
42159
42160
42161 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
42162   int jresult ;
42163   int result;
42164
42165   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
42166   jresult = (int)result;
42167   return jresult;
42168 }
42169
42170
42171 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
42172   int jresult ;
42173   int result;
42174
42175   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
42176   jresult = (int)result;
42177   return jresult;
42178 }
42179
42180
42181 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
42182   int jresult ;
42183   int result;
42184
42185   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
42186   jresult = (int)result;
42187   return jresult;
42188 }
42189
42190
42191 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
42192   int jresult ;
42193   int result;
42194
42195   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
42196   jresult = (int)result;
42197   return jresult;
42198 }
42199
42200
42201 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
42202   int jresult ;
42203   int result;
42204
42205   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
42206   jresult = (int)result;
42207   return jresult;
42208 }
42209
42210
42211 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
42212   int jresult ;
42213   int result;
42214
42215   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
42216   jresult = (int)result;
42217   return jresult;
42218 }
42219
42220
42221 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
42222   int jresult ;
42223   int result;
42224
42225   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
42226   jresult = (int)result;
42227   return jresult;
42228 }
42229
42230
42231 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
42232   int jresult ;
42233   int result;
42234
42235   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
42236   jresult = (int)result;
42237   return jresult;
42238 }
42239
42240
42241 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
42242   int jresult ;
42243   int result;
42244
42245   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
42246   jresult = (int)result;
42247   return jresult;
42248 }
42249
42250
42251 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
42252   int jresult ;
42253   int result;
42254
42255   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
42256   jresult = (int)result;
42257   return jresult;
42258 }
42259
42260
42261 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
42262   void * jresult ;
42263   Dali::Toolkit::ItemView::Property *result = 0 ;
42264
42265   {
42266     try {
42267       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
42268     } CALL_CATCH_EXCEPTION(0);
42269   }
42270
42271   jresult = (void *)result;
42272   return jresult;
42273 }
42274
42275
42276 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
42277   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
42278
42279   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
42280   {
42281     try {
42282       delete arg1;
42283     } CALL_CATCH_EXCEPTION();
42284   }
42285
42286 }
42287
42288
42289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
42290   void * jresult ;
42291   Dali::Toolkit::ItemView *result = 0 ;
42292
42293   {
42294     try {
42295       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
42296     } CALL_CATCH_EXCEPTION(0);
42297   }
42298
42299   jresult = (void *)result;
42300   return jresult;
42301 }
42302
42303
42304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
42305   void * jresult ;
42306   Dali::Toolkit::ItemView *arg1 = 0 ;
42307   Dali::Toolkit::ItemView *result = 0 ;
42308
42309   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42310   if (!arg1) {
42311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
42312     return 0;
42313   }
42314   {
42315     try {
42316       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
42317     } CALL_CATCH_EXCEPTION(0);
42318   }
42319
42320   jresult = (void *)result;
42321   return jresult;
42322 }
42323
42324
42325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
42326   void * jresult ;
42327   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42328   Dali::Toolkit::ItemView *arg2 = 0 ;
42329   Dali::Toolkit::ItemView *result = 0 ;
42330
42331   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42332   arg2 = (Dali::Toolkit::ItemView *)jarg2;
42333   if (!arg2) {
42334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
42335     return 0;
42336   }
42337   {
42338     try {
42339       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
42340     } CALL_CATCH_EXCEPTION(0);
42341   }
42342
42343   jresult = (void *)result;
42344   return jresult;
42345 }
42346
42347
42348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
42349   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42350
42351   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42352   {
42353     try {
42354       delete arg1;
42355     } CALL_CATCH_EXCEPTION();
42356   }
42357
42358 }
42359
42360
42361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
42362   void * jresult ;
42363   Dali::Toolkit::ItemFactory *arg1 = 0 ;
42364   Dali::Toolkit::ItemView result;
42365
42366   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
42367   if (!arg1) {
42368     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
42369     return 0;
42370   }
42371   {
42372     try {
42373       result = Dali::Toolkit::ItemView::New(*arg1);
42374     } CALL_CATCH_EXCEPTION(0);
42375   }
42376
42377   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
42378   return jresult;
42379 }
42380
42381
42382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
42383   void * jresult ;
42384   Dali::BaseHandle arg1 ;
42385   Dali::BaseHandle *argp1 ;
42386   Dali::Toolkit::ItemView result;
42387
42388   argp1 = (Dali::BaseHandle *)jarg1;
42389   if (!argp1) {
42390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42391     return 0;
42392   }
42393   arg1 = *argp1;
42394   {
42395     try {
42396       result = Dali::Toolkit::ItemView::DownCast(arg1);
42397     } CALL_CATCH_EXCEPTION(0);
42398   }
42399
42400   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
42401   return jresult;
42402 }
42403
42404
42405 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
42406   unsigned int jresult ;
42407   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42408   unsigned int result;
42409
42410   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42411   {
42412     try {
42413       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
42414     } CALL_CATCH_EXCEPTION(0);
42415   }
42416
42417   jresult = result;
42418   return jresult;
42419 }
42420
42421
42422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
42423   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42424   Dali::Toolkit::ItemLayout *arg2 = 0 ;
42425
42426   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42427   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
42428   if (!arg2) {
42429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
42430     return ;
42431   }
42432   {
42433     try {
42434       (arg1)->AddLayout(*arg2);
42435     } CALL_CATCH_EXCEPTION();
42436   }
42437
42438 }
42439
42440
42441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
42442   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42443   unsigned int arg2 ;
42444
42445   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42446   arg2 = (unsigned int)jarg2;
42447   {
42448     try {
42449       (arg1)->RemoveLayout(arg2);
42450     } CALL_CATCH_EXCEPTION();
42451   }
42452
42453 }
42454
42455
42456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
42457   void * jresult ;
42458   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42459   unsigned int arg2 ;
42460   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
42461
42462   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42463   arg2 = (unsigned int)jarg2;
42464   {
42465     try {
42466       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
42467     } CALL_CATCH_EXCEPTION(0);
42468   }
42469
42470   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
42471   return jresult;
42472 }
42473
42474
42475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
42476   void * jresult ;
42477   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42478   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
42479
42480   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42481   {
42482     try {
42483       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
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 float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
42493   float jresult ;
42494   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42495   Dali::Toolkit::ItemId arg2 ;
42496   float result;
42497
42498   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42499   arg2 = (Dali::Toolkit::ItemId)jarg2;
42500   {
42501     try {
42502       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
42503     } CALL_CATCH_EXCEPTION(0);
42504   }
42505
42506   jresult = result;
42507   return jresult;
42508 }
42509
42510
42511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
42512   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42513   unsigned int arg2 ;
42514   Dali::Vector3 arg3 ;
42515   float arg4 ;
42516   Dali::Vector3 *argp3 ;
42517
42518   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42519   arg2 = (unsigned int)jarg2;
42520   argp3 = (Dali::Vector3 *)jarg3;
42521   if (!argp3) {
42522     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
42523     return ;
42524   }
42525   arg3 = *argp3;
42526   arg4 = (float)jarg4;
42527   {
42528     try {
42529       (arg1)->ActivateLayout(arg2,arg3,arg4);
42530     } CALL_CATCH_EXCEPTION();
42531   }
42532
42533 }
42534
42535
42536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
42537   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42538
42539   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42540   {
42541     try {
42542       (arg1)->DeactivateCurrentLayout();
42543     } CALL_CATCH_EXCEPTION();
42544   }
42545
42546 }
42547
42548
42549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
42550   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42551   float arg2 ;
42552
42553   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42554   arg2 = (float)jarg2;
42555   {
42556     try {
42557       (arg1)->SetMinimumSwipeSpeed(arg2);
42558     } CALL_CATCH_EXCEPTION();
42559   }
42560
42561 }
42562
42563
42564 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
42565   float jresult ;
42566   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42567   float result;
42568
42569   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42570   {
42571     try {
42572       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
42573     } CALL_CATCH_EXCEPTION(0);
42574   }
42575
42576   jresult = result;
42577   return jresult;
42578 }
42579
42580
42581 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
42582   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42583   float arg2 ;
42584
42585   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42586   arg2 = (float)jarg2;
42587   {
42588     try {
42589       (arg1)->SetMinimumSwipeDistance(arg2);
42590     } CALL_CATCH_EXCEPTION();
42591   }
42592
42593 }
42594
42595
42596 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
42597   float jresult ;
42598   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42599   float result;
42600
42601   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42602   {
42603     try {
42604       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
42605     } CALL_CATCH_EXCEPTION(0);
42606   }
42607
42608   jresult = result;
42609   return jresult;
42610 }
42611
42612
42613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
42614   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42615   float arg2 ;
42616
42617   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42618   arg2 = (float)jarg2;
42619   {
42620     try {
42621       (arg1)->SetWheelScrollDistanceStep(arg2);
42622     } CALL_CATCH_EXCEPTION();
42623   }
42624
42625 }
42626
42627
42628 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
42629   float jresult ;
42630   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42631   float result;
42632
42633   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42634   {
42635     try {
42636       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
42637     } CALL_CATCH_EXCEPTION(0);
42638   }
42639
42640   jresult = result;
42641   return jresult;
42642 }
42643
42644
42645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
42646   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42647   bool arg2 ;
42648
42649   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42650   arg2 = jarg2 ? true : false;
42651   {
42652     try {
42653       (arg1)->SetAnchoring(arg2);
42654     } CALL_CATCH_EXCEPTION();
42655   }
42656
42657 }
42658
42659 //// ========================= end of part 3 =============================
42660
42661 //// ========================== start part 4 ===============================
42662
42663
42664 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
42665   unsigned int jresult ;
42666   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42667   bool result;
42668
42669   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42670   {
42671     try {
42672       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
42673     } CALL_CATCH_EXCEPTION(0);
42674   }
42675
42676   jresult = result;
42677   return jresult;
42678 }
42679
42680
42681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
42682   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42683   float arg2 ;
42684
42685   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42686   arg2 = (float)jarg2;
42687   {
42688     try {
42689       (arg1)->SetAnchoringDuration(arg2);
42690     } CALL_CATCH_EXCEPTION();
42691   }
42692
42693 }
42694
42695
42696 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
42697   float jresult ;
42698   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42699   float result;
42700
42701   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42702   {
42703     try {
42704       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
42705     } CALL_CATCH_EXCEPTION(0);
42706   }
42707
42708   jresult = result;
42709   return jresult;
42710 }
42711
42712
42713 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
42714   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42715   Dali::Toolkit::ItemId arg2 ;
42716   float arg3 ;
42717
42718   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42719   arg2 = (Dali::Toolkit::ItemId)jarg2;
42720   arg3 = (float)jarg3;
42721   {
42722     try {
42723       (arg1)->ScrollToItem(arg2,arg3);
42724     } CALL_CATCH_EXCEPTION();
42725   }
42726
42727 }
42728
42729
42730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
42731   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42732   float arg2 ;
42733
42734   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42735   arg2 = (float)jarg2;
42736   {
42737     try {
42738       (arg1)->SetRefreshInterval(arg2);
42739     } CALL_CATCH_EXCEPTION();
42740   }
42741
42742 }
42743
42744
42745 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
42746   float jresult ;
42747   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42748   float result;
42749
42750   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42751   {
42752     try {
42753       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
42754     } CALL_CATCH_EXCEPTION(0);
42755   }
42756
42757   jresult = result;
42758   return jresult;
42759 }
42760
42761
42762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
42763   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42764
42765   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42766   {
42767     try {
42768       (arg1)->Refresh();
42769     } CALL_CATCH_EXCEPTION();
42770   }
42771
42772 }
42773
42774
42775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
42776   void * jresult ;
42777   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42778   Dali::Toolkit::ItemId arg2 ;
42779   Dali::Actor result;
42780
42781   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42782   arg2 = (Dali::Toolkit::ItemId)jarg2;
42783   {
42784     try {
42785       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
42786     } CALL_CATCH_EXCEPTION(0);
42787   }
42788
42789   jresult = new Dali::Actor((const Dali::Actor &)result);
42790   return jresult;
42791 }
42792
42793
42794 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
42795   unsigned int jresult ;
42796   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42797   Dali::Actor arg2 ;
42798   Dali::Actor *argp2 ;
42799   Dali::Toolkit::ItemId result;
42800
42801   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42802   argp2 = (Dali::Actor *)jarg2;
42803   if (!argp2) {
42804     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
42805     return 0;
42806   }
42807   arg2 = *argp2;
42808   {
42809     try {
42810       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
42811     } CALL_CATCH_EXCEPTION(0);
42812   }
42813
42814   jresult = result;
42815   return jresult;
42816 }
42817
42818
42819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
42820   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42821   Dali::Toolkit::Item arg2 ;
42822   float arg3 ;
42823   Dali::Toolkit::Item *argp2 ;
42824
42825   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42826   argp2 = (Dali::Toolkit::Item *)jarg2;
42827   if (!argp2) {
42828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
42829     return ;
42830   }
42831   arg2 = *argp2;
42832   arg3 = (float)jarg3;
42833   {
42834     try {
42835       (arg1)->InsertItem(arg2,arg3);
42836     } CALL_CATCH_EXCEPTION();
42837   }
42838
42839 }
42840
42841
42842 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
42843   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42844   Dali::Toolkit::ItemContainer *arg2 = 0 ;
42845   float arg3 ;
42846
42847   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42848   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
42849   if (!arg2) {
42850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
42851     return ;
42852   }
42853   arg3 = (float)jarg3;
42854   {
42855     try {
42856       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
42857     } CALL_CATCH_EXCEPTION();
42858   }
42859
42860 }
42861
42862
42863 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
42864   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42865   Dali::Toolkit::ItemId arg2 ;
42866   float arg3 ;
42867
42868   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42869   arg2 = (Dali::Toolkit::ItemId)jarg2;
42870   arg3 = (float)jarg3;
42871   {
42872     try {
42873       (arg1)->RemoveItem(arg2,arg3);
42874     } CALL_CATCH_EXCEPTION();
42875   }
42876
42877 }
42878
42879
42880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
42881   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42882   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
42883   float arg3 ;
42884
42885   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42886   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
42887   if (!arg2) {
42888     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
42889     return ;
42890   }
42891   arg3 = (float)jarg3;
42892   {
42893     try {
42894       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
42895     } CALL_CATCH_EXCEPTION();
42896   }
42897
42898 }
42899
42900
42901 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
42902   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42903   Dali::Toolkit::Item arg2 ;
42904   float arg3 ;
42905   Dali::Toolkit::Item *argp2 ;
42906
42907   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42908   argp2 = (Dali::Toolkit::Item *)jarg2;
42909   if (!argp2) {
42910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
42911     return ;
42912   }
42913   arg2 = *argp2;
42914   arg3 = (float)jarg3;
42915   {
42916     try {
42917       (arg1)->ReplaceItem(arg2,arg3);
42918     } CALL_CATCH_EXCEPTION();
42919   }
42920
42921 }
42922
42923
42924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
42925   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42926   Dali::Toolkit::ItemContainer *arg2 = 0 ;
42927   float arg3 ;
42928
42929   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42930   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
42931   if (!arg2) {
42932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
42933     return ;
42934   }
42935   arg3 = (float)jarg3;
42936   {
42937     try {
42938       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
42939     } CALL_CATCH_EXCEPTION();
42940   }
42941
42942 }
42943
42944
42945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
42946   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42947   Dali::Vector3 *arg2 = 0 ;
42948
42949   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42950   arg2 = (Dali::Vector3 *)jarg2;
42951   if (!arg2) {
42952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
42953     return ;
42954   }
42955   {
42956     try {
42957       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
42958     } CALL_CATCH_EXCEPTION();
42959   }
42960
42961 }
42962
42963
42964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
42965   void * jresult ;
42966   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42967   Dali::Vector3 result;
42968
42969   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42970   {
42971     try {
42972       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
42973     } CALL_CATCH_EXCEPTION(0);
42974   }
42975
42976   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
42977   return jresult;
42978 }
42979
42980
42981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
42982   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
42983   Dali::Vector3 *arg2 = 0 ;
42984
42985   arg1 = (Dali::Toolkit::ItemView *)jarg1;
42986   arg2 = (Dali::Vector3 *)jarg2;
42987   if (!arg2) {
42988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
42989     return ;
42990   }
42991   {
42992     try {
42993       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
42994     } CALL_CATCH_EXCEPTION();
42995   }
42996
42997 }
42998
42999
43000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
43001   void * jresult ;
43002   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
43003   Dali::Vector3 result;
43004
43005   arg1 = (Dali::Toolkit::ItemView *)jarg1;
43006   {
43007     try {
43008       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
43009     } CALL_CATCH_EXCEPTION(0);
43010   }
43011
43012   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
43013   return jresult;
43014 }
43015
43016
43017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
43018   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
43019   Dali::Toolkit::ItemRange *arg2 = 0 ;
43020
43021   arg1 = (Dali::Toolkit::ItemView *)jarg1;
43022   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
43023   if (!arg2) {
43024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
43025     return ;
43026   }
43027   {
43028     try {
43029       (arg1)->GetItemsRange(*arg2);
43030     } CALL_CATCH_EXCEPTION();
43031   }
43032
43033 }
43034
43035
43036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
43037   void * jresult ;
43038   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
43039   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
43040
43041   arg1 = (Dali::Toolkit::ItemView *)jarg1;
43042   {
43043     try {
43044       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
43045     } CALL_CATCH_EXCEPTION(0);
43046   }
43047
43048   jresult = (void *)result;
43049   return jresult;
43050 }
43051
43052
43053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
43054   Dali::Vector3 *arg1 = 0 ;
43055   PropertyInputContainer *arg2 = 0 ;
43056
43057   arg1 = (Dali::Vector3 *)jarg1;
43058   if (!arg1) {
43059     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43060     return ;
43061   }
43062   arg2 = (PropertyInputContainer *)jarg2;
43063   if (!arg2) {
43064     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
43065     return ;
43066   }
43067   {
43068     try {
43069       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
43070     } CALL_CATCH_EXCEPTION();
43071   }
43072
43073 }
43074
43075
43076 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
43077   Dali::Vector3 *arg1 = 0 ;
43078   PropertyInputContainer *arg2 = 0 ;
43079
43080   arg1 = (Dali::Vector3 *)jarg1;
43081   if (!arg1) {
43082     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43083     return ;
43084   }
43085   arg2 = (PropertyInputContainer *)jarg2;
43086   if (!arg2) {
43087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
43088     return ;
43089   }
43090   {
43091     try {
43092       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
43093     } CALL_CATCH_EXCEPTION();
43094   }
43095
43096 }
43097
43098
43099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
43100   void * jresult ;
43101   Dali::Toolkit::ScrollViewEffect *result = 0 ;
43102
43103   {
43104     try {
43105       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
43106     } CALL_CATCH_EXCEPTION(0);
43107   }
43108
43109   jresult = (void *)result;
43110   return jresult;
43111 }
43112
43113
43114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
43115   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
43116
43117   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
43118   {
43119     try {
43120       delete arg1;
43121     } CALL_CATCH_EXCEPTION();
43122   }
43123
43124 }
43125
43126
43127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
43128   void * jresult ;
43129   Dali::Path arg1 ;
43130   Dali::Vector3 *arg2 = 0 ;
43131   Dali::Property::Index arg3 ;
43132   Dali::Vector3 *arg4 = 0 ;
43133   unsigned int arg5 ;
43134   Dali::Path *argp1 ;
43135   Dali::Toolkit::ScrollViewPagePathEffect result;
43136
43137   argp1 = (Dali::Path *)jarg1;
43138   if (!argp1) {
43139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
43140     return 0;
43141   }
43142   arg1 = *argp1;
43143   arg2 = (Dali::Vector3 *)jarg2;
43144   if (!arg2) {
43145     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43146     return 0;
43147   }
43148   arg3 = (Dali::Property::Index)jarg3;
43149   arg4 = (Dali::Vector3 *)jarg4;
43150   if (!arg4) {
43151     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43152     return 0;
43153   }
43154   arg5 = (unsigned int)jarg5;
43155   {
43156     try {
43157       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
43158     } CALL_CATCH_EXCEPTION(0);
43159   }
43160
43161   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
43162   return jresult;
43163 }
43164
43165
43166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
43167   void * jresult ;
43168   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
43169
43170   {
43171     try {
43172       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
43173     } CALL_CATCH_EXCEPTION(0);
43174   }
43175
43176   jresult = (void *)result;
43177   return jresult;
43178 }
43179
43180
43181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
43182   void * jresult ;
43183   Dali::BaseHandle arg1 ;
43184   Dali::BaseHandle *argp1 ;
43185   Dali::Toolkit::ScrollViewPagePathEffect result;
43186
43187   argp1 = (Dali::BaseHandle *)jarg1;
43188   if (!argp1) {
43189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43190     return 0;
43191   }
43192   arg1 = *argp1;
43193   {
43194     try {
43195       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
43196     } CALL_CATCH_EXCEPTION(0);
43197   }
43198
43199   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
43200   return jresult;
43201 }
43202
43203
43204 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
43205   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
43206   Dali::Actor arg2 ;
43207   unsigned int arg3 ;
43208   Dali::Actor *argp2 ;
43209
43210   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
43211   argp2 = (Dali::Actor *)jarg2;
43212   if (!argp2) {
43213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
43214     return ;
43215   }
43216   arg2 = *argp2;
43217   arg3 = (unsigned int)jarg3;
43218   {
43219     try {
43220       (arg1)->ApplyToPage(arg2,arg3);
43221     } CALL_CATCH_EXCEPTION();
43222   }
43223
43224 }
43225
43226
43227 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
43228   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
43229
43230   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
43231   {
43232     try {
43233       delete arg1;
43234     } CALL_CATCH_EXCEPTION();
43235   }
43236
43237 }
43238
43239
43240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
43241   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
43242   Dali::Toolkit::ClampState arg2 ;
43243
43244   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
43245   arg2 = (Dali::Toolkit::ClampState)jarg2;
43246   if (arg1) (arg1)->x = arg2;
43247 }
43248
43249
43250 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
43251   int jresult ;
43252   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
43253   Dali::Toolkit::ClampState result;
43254
43255   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
43256   result = (Dali::Toolkit::ClampState) ((arg1)->x);
43257   jresult = (int)result;
43258   return jresult;
43259 }
43260
43261
43262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
43263   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
43264   Dali::Toolkit::ClampState arg2 ;
43265
43266   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
43267   arg2 = (Dali::Toolkit::ClampState)jarg2;
43268   if (arg1) (arg1)->y = arg2;
43269 }
43270
43271
43272 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
43273   int jresult ;
43274   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
43275   Dali::Toolkit::ClampState result;
43276
43277   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
43278   result = (Dali::Toolkit::ClampState) ((arg1)->y);
43279   jresult = (int)result;
43280   return jresult;
43281 }
43282
43283
43284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
43285   void * jresult ;
43286   Dali::Toolkit::ClampState2D *result = 0 ;
43287
43288   {
43289     try {
43290       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
43291     } CALL_CATCH_EXCEPTION(0);
43292   }
43293
43294   jresult = (void *)result;
43295   return jresult;
43296 }
43297
43298
43299 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
43300   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
43301
43302   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
43303   {
43304     try {
43305       delete arg1;
43306     } CALL_CATCH_EXCEPTION();
43307   }
43308
43309 }
43310
43311
43312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
43313   void * jresult ;
43314   float arg1 ;
43315   float arg2 ;
43316   bool arg3 ;
43317   Dali::Toolkit::RulerDomain *result = 0 ;
43318
43319   arg1 = (float)jarg1;
43320   arg2 = (float)jarg2;
43321   arg3 = jarg3 ? true : false;
43322   {
43323     try {
43324       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
43325     } CALL_CATCH_EXCEPTION(0);
43326   }
43327
43328   jresult = (void *)result;
43329   return jresult;
43330 }
43331
43332
43333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
43334   void * jresult ;
43335   float arg1 ;
43336   float arg2 ;
43337   Dali::Toolkit::RulerDomain *result = 0 ;
43338
43339   arg1 = (float)jarg1;
43340   arg2 = (float)jarg2;
43341   {
43342     try {
43343       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
43344     } CALL_CATCH_EXCEPTION(0);
43345   }
43346
43347   jresult = (void *)result;
43348   return jresult;
43349 }
43350
43351
43352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
43353   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
43354   float arg2 ;
43355
43356   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
43357   arg2 = (float)jarg2;
43358   if (arg1) (arg1)->min = arg2;
43359 }
43360
43361
43362 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
43363   float jresult ;
43364   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
43365   float result;
43366
43367   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
43368   result = (float) ((arg1)->min);
43369   jresult = result;
43370   return jresult;
43371 }
43372
43373
43374 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
43375   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
43376   float arg2 ;
43377
43378   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
43379   arg2 = (float)jarg2;
43380   if (arg1) (arg1)->max = arg2;
43381 }
43382
43383
43384 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
43385   float jresult ;
43386   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
43387   float result;
43388
43389   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
43390   result = (float) ((arg1)->max);
43391   jresult = result;
43392   return jresult;
43393 }
43394
43395
43396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
43397   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
43398   bool arg2 ;
43399
43400   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
43401   arg2 = jarg2 ? true : false;
43402   if (arg1) (arg1)->enabled = arg2;
43403 }
43404
43405
43406 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
43407   unsigned int jresult ;
43408   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
43409   bool result;
43410
43411   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
43412   result = (bool) ((arg1)->enabled);
43413   jresult = result;
43414   return jresult;
43415 }
43416
43417
43418 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
43419   float jresult ;
43420   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
43421   float arg2 ;
43422   float arg3 ;
43423   float arg4 ;
43424   float result;
43425
43426   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
43427   arg2 = (float)jarg2;
43428   arg3 = (float)jarg3;
43429   arg4 = (float)jarg4;
43430   {
43431     try {
43432       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
43433     } CALL_CATCH_EXCEPTION(0);
43434   }
43435
43436   jresult = result;
43437   return jresult;
43438 }
43439
43440
43441 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
43442   float jresult ;
43443   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
43444   float arg2 ;
43445   float arg3 ;
43446   float result;
43447
43448   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
43449   arg2 = (float)jarg2;
43450   arg3 = (float)jarg3;
43451   {
43452     try {
43453       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
43454     } CALL_CATCH_EXCEPTION(0);
43455   }
43456
43457   jresult = result;
43458   return jresult;
43459 }
43460
43461
43462 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
43463   float jresult ;
43464   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
43465   float arg2 ;
43466   float result;
43467
43468   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
43469   arg2 = (float)jarg2;
43470   {
43471     try {
43472       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
43473     } CALL_CATCH_EXCEPTION(0);
43474   }
43475
43476   jresult = result;
43477   return jresult;
43478 }
43479
43480
43481 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
43482   float jresult ;
43483   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
43484   float arg2 ;
43485   float arg3 ;
43486   float arg4 ;
43487   Dali::Toolkit::ClampState *arg5 = 0 ;
43488   float result;
43489
43490   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
43491   arg2 = (float)jarg2;
43492   arg3 = (float)jarg3;
43493   arg4 = (float)jarg4;
43494   arg5 = (Dali::Toolkit::ClampState *)jarg5;
43495   if (!arg5) {
43496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
43497     return 0;
43498   }
43499   {
43500     try {
43501       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
43502     } CALL_CATCH_EXCEPTION(0);
43503   }
43504
43505   jresult = result;
43506   return jresult;
43507 }
43508
43509
43510 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
43511   float jresult ;
43512   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
43513   float result;
43514
43515   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
43516   {
43517     try {
43518       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
43519     } CALL_CATCH_EXCEPTION(0);
43520   }
43521
43522   jresult = result;
43523   return jresult;
43524 }
43525
43526
43527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
43528   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
43529
43530   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
43531   {
43532     try {
43533       delete arg1;
43534     } CALL_CATCH_EXCEPTION();
43535   }
43536
43537 }
43538
43539
43540 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
43541   float jresult ;
43542   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43543   float arg2 ;
43544   float arg3 ;
43545   float result;
43546
43547   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43548   arg2 = (float)jarg2;
43549   arg3 = (float)jarg3;
43550   {
43551     try {
43552       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
43553     } CALL_CATCH_EXCEPTION(0);
43554   }
43555
43556   jresult = result;
43557   return jresult;
43558 }
43559
43560
43561 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
43562   float jresult ;
43563   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43564   float arg2 ;
43565   float result;
43566
43567   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43568   arg2 = (float)jarg2;
43569   {
43570     try {
43571       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
43572     } CALL_CATCH_EXCEPTION(0);
43573   }
43574
43575   jresult = result;
43576   return jresult;
43577 }
43578
43579
43580 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
43581   float jresult ;
43582   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43583   unsigned int arg2 ;
43584   unsigned int *arg3 = 0 ;
43585   bool arg4 ;
43586   float result;
43587
43588   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43589   arg2 = (unsigned int)jarg2;
43590   arg3 = (unsigned int *)jarg3;
43591   arg4 = jarg4 ? true : false;
43592   {
43593     try {
43594       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
43595     } CALL_CATCH_EXCEPTION(0);
43596   }
43597
43598   jresult = result;
43599   return jresult;
43600 }
43601
43602
43603 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
43604   unsigned int jresult ;
43605   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43606   float arg2 ;
43607   bool arg3 ;
43608   unsigned int result;
43609
43610   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43611   arg2 = (float)jarg2;
43612   arg3 = jarg3 ? true : false;
43613   {
43614     try {
43615       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
43616     } CALL_CATCH_EXCEPTION(0);
43617   }
43618
43619   jresult = result;
43620   return jresult;
43621 }
43622
43623
43624 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
43625   unsigned int jresult ;
43626   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43627   unsigned int result;
43628
43629   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43630   {
43631     try {
43632       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
43633     } CALL_CATCH_EXCEPTION(0);
43634   }
43635
43636   jresult = result;
43637   return jresult;
43638 }
43639
43640
43641 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
43642   int jresult ;
43643   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43644   Dali::Toolkit::Ruler::RulerType result;
43645
43646   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43647   {
43648     try {
43649       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
43650     } CALL_CATCH_EXCEPTION(0);
43651   }
43652
43653   jresult = (int)result;
43654   return jresult;
43655 }
43656
43657
43658 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
43659   unsigned int jresult ;
43660   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43661   bool result;
43662
43663   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43664   {
43665     try {
43666       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
43667     } CALL_CATCH_EXCEPTION(0);
43668   }
43669
43670   jresult = result;
43671   return jresult;
43672 }
43673
43674
43675 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
43676   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43677
43678   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43679   {
43680     try {
43681       (arg1)->Enable();
43682     } CALL_CATCH_EXCEPTION();
43683   }
43684
43685 }
43686
43687
43688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
43689   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43690
43691   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43692   {
43693     try {
43694       (arg1)->Disable();
43695     } CALL_CATCH_EXCEPTION();
43696   }
43697
43698 }
43699
43700
43701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
43702   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43703   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
43704   Dali::Toolkit::RulerDomain *argp2 ;
43705
43706   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43707   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
43708   if (!argp2) {
43709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
43710     return ;
43711   }
43712   arg2 = *argp2;
43713   {
43714     try {
43715       (arg1)->SetDomain(arg2);
43716     } CALL_CATCH_EXCEPTION();
43717   }
43718
43719 }
43720
43721
43722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
43723   void * jresult ;
43724   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43725   Dali::Toolkit::RulerDomain *result = 0 ;
43726
43727   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43728   {
43729     try {
43730       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
43731     } CALL_CATCH_EXCEPTION(0);
43732   }
43733
43734   jresult = (void *)result;
43735   return jresult;
43736 }
43737
43738
43739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
43740   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43741
43742   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43743   {
43744     try {
43745       (arg1)->DisableDomain();
43746     } CALL_CATCH_EXCEPTION();
43747   }
43748
43749 }
43750
43751
43752 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
43753   float jresult ;
43754   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43755   float arg2 ;
43756   float arg3 ;
43757   float arg4 ;
43758   float result;
43759
43760   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43761   arg2 = (float)jarg2;
43762   arg3 = (float)jarg3;
43763   arg4 = (float)jarg4;
43764   {
43765     try {
43766       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
43767     } CALL_CATCH_EXCEPTION(0);
43768   }
43769
43770   jresult = result;
43771   return jresult;
43772 }
43773
43774
43775 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
43776   float jresult ;
43777   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43778   float arg2 ;
43779   float arg3 ;
43780   float result;
43781
43782   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43783   arg2 = (float)jarg2;
43784   arg3 = (float)jarg3;
43785   {
43786     try {
43787       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
43788     } CALL_CATCH_EXCEPTION(0);
43789   }
43790
43791   jresult = result;
43792   return jresult;
43793 }
43794
43795
43796 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
43797   float jresult ;
43798   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43799   float arg2 ;
43800   float result;
43801
43802   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43803   arg2 = (float)jarg2;
43804   {
43805     try {
43806       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
43807     } CALL_CATCH_EXCEPTION(0);
43808   }
43809
43810   jresult = result;
43811   return jresult;
43812 }
43813
43814
43815 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
43816   float jresult ;
43817   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43818   float arg2 ;
43819   float arg3 ;
43820   float arg4 ;
43821   Dali::Toolkit::ClampState *arg5 = 0 ;
43822   float result;
43823
43824   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43825   arg2 = (float)jarg2;
43826   arg3 = (float)jarg3;
43827   arg4 = (float)jarg4;
43828   arg5 = (Dali::Toolkit::ClampState *)jarg5;
43829   if (!arg5) {
43830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
43831     return 0;
43832   }
43833   {
43834     try {
43835       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
43836     } CALL_CATCH_EXCEPTION(0);
43837   }
43838
43839   jresult = result;
43840   return jresult;
43841 }
43842
43843
43844 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
43845   float jresult ;
43846   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43847   float arg2 ;
43848   float arg3 ;
43849   float arg4 ;
43850   float arg5 ;
43851   float result;
43852
43853   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43854   arg2 = (float)jarg2;
43855   arg3 = (float)jarg3;
43856   arg4 = (float)jarg4;
43857   arg5 = (float)jarg5;
43858   {
43859     try {
43860       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
43861     } CALL_CATCH_EXCEPTION(0);
43862   }
43863
43864   jresult = result;
43865   return jresult;
43866 }
43867
43868
43869 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
43870   float jresult ;
43871   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43872   float arg2 ;
43873   float arg3 ;
43874   float arg4 ;
43875   float result;
43876
43877   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43878   arg2 = (float)jarg2;
43879   arg3 = (float)jarg3;
43880   arg4 = (float)jarg4;
43881   {
43882     try {
43883       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
43884     } CALL_CATCH_EXCEPTION(0);
43885   }
43886
43887   jresult = result;
43888   return jresult;
43889 }
43890
43891
43892 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
43893   float jresult ;
43894   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43895   float arg2 ;
43896   float arg3 ;
43897   float result;
43898
43899   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43900   arg2 = (float)jarg2;
43901   arg3 = (float)jarg3;
43902   {
43903     try {
43904       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
43905     } CALL_CATCH_EXCEPTION(0);
43906   }
43907
43908   jresult = result;
43909   return jresult;
43910 }
43911
43912
43913 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
43914   float jresult ;
43915   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43916   float arg2 ;
43917   float result;
43918
43919   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43920   arg2 = (float)jarg2;
43921   {
43922     try {
43923       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
43924     } CALL_CATCH_EXCEPTION(0);
43925   }
43926
43927   jresult = result;
43928   return jresult;
43929 }
43930
43931
43932 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
43933   float jresult ;
43934   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
43935   float arg2 ;
43936   float arg3 ;
43937   float arg4 ;
43938   float arg5 ;
43939   Dali::Toolkit::ClampState *arg6 = 0 ;
43940   float result;
43941
43942   arg1 = (Dali::Toolkit::Ruler *)jarg1;
43943   arg2 = (float)jarg2;
43944   arg3 = (float)jarg3;
43945   arg4 = (float)jarg4;
43946   arg5 = (float)jarg5;
43947   arg6 = (Dali::Toolkit::ClampState *)jarg6;
43948   if (!arg6) {
43949     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
43950     return 0;
43951   }
43952   {
43953     try {
43954       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
43955     } CALL_CATCH_EXCEPTION(0);
43956   }
43957
43958   jresult = result;
43959   return jresult;
43960 }
43961
43962
43963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
43964   void * jresult ;
43965   Dali::Toolkit::DefaultRuler *result = 0 ;
43966
43967   {
43968     try {
43969       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
43970     } CALL_CATCH_EXCEPTION(0);
43971   }
43972
43973   jresult = (void *)result;
43974   return jresult;
43975 }
43976
43977
43978 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
43979   float jresult ;
43980   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
43981   float arg2 ;
43982   float arg3 ;
43983   float result;
43984
43985   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
43986   arg2 = (float)jarg2;
43987   arg3 = (float)jarg3;
43988   {
43989     try {
43990       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
43991     } CALL_CATCH_EXCEPTION(0);
43992   }
43993
43994   jresult = result;
43995   return jresult;
43996 }
43997
43998
43999 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
44000   float jresult ;
44001   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
44002   unsigned int arg2 ;
44003   unsigned int *arg3 = 0 ;
44004   bool arg4 ;
44005   float result;
44006
44007   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
44008   arg2 = (unsigned int)jarg2;
44009   arg3 = (unsigned int *)jarg3;
44010   arg4 = jarg4 ? true : false;
44011   {
44012     try {
44013       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
44014     } CALL_CATCH_EXCEPTION(0);
44015   }
44016
44017   jresult = result;
44018   return jresult;
44019 }
44020
44021
44022 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
44023   unsigned int jresult ;
44024   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
44025   float arg2 ;
44026   bool arg3 ;
44027   unsigned int result;
44028
44029   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
44030   arg2 = (float)jarg2;
44031   arg3 = jarg3 ? true : false;
44032   {
44033     try {
44034       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
44035     } CALL_CATCH_EXCEPTION(0);
44036   }
44037
44038   jresult = result;
44039   return jresult;
44040 }
44041
44042
44043 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
44044   unsigned int jresult ;
44045   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
44046   unsigned int result;
44047
44048   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
44049   {
44050     try {
44051       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
44052     } CALL_CATCH_EXCEPTION(0);
44053   }
44054
44055   jresult = result;
44056   return jresult;
44057 }
44058
44059
44060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
44061   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
44062
44063   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
44064   {
44065     try {
44066       delete arg1;
44067     } CALL_CATCH_EXCEPTION();
44068   }
44069
44070 }
44071
44072
44073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
44074   void * jresult ;
44075   float arg1 ;
44076   Dali::Toolkit::FixedRuler *result = 0 ;
44077
44078   arg1 = (float)jarg1;
44079   {
44080     try {
44081       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
44082     } CALL_CATCH_EXCEPTION(0);
44083   }
44084
44085   jresult = (void *)result;
44086   return jresult;
44087 }
44088
44089
44090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
44091   void * jresult ;
44092   Dali::Toolkit::FixedRuler *result = 0 ;
44093
44094   {
44095     try {
44096       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
44097     } CALL_CATCH_EXCEPTION(0);
44098   }
44099
44100   jresult = (void *)result;
44101   return jresult;
44102 }
44103
44104
44105 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
44106   float jresult ;
44107   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
44108   float arg2 ;
44109   float arg3 ;
44110   float result;
44111
44112   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
44113   arg2 = (float)jarg2;
44114   arg3 = (float)jarg3;
44115   {
44116     try {
44117       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
44118     } CALL_CATCH_EXCEPTION(0);
44119   }
44120
44121   jresult = result;
44122   return jresult;
44123 }
44124
44125
44126 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
44127   float jresult ;
44128   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
44129   unsigned int arg2 ;
44130   unsigned int *arg3 = 0 ;
44131   bool arg4 ;
44132   float result;
44133
44134   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
44135   arg2 = (unsigned int)jarg2;
44136   arg3 = (unsigned int *)jarg3;
44137   arg4 = jarg4 ? true : false;
44138   {
44139     try {
44140       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
44141     } CALL_CATCH_EXCEPTION(0);
44142   }
44143
44144   jresult = result;
44145   return jresult;
44146 }
44147
44148
44149 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
44150   unsigned int jresult ;
44151   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
44152   float arg2 ;
44153   bool arg3 ;
44154   unsigned int result;
44155
44156   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
44157   arg2 = (float)jarg2;
44158   arg3 = jarg3 ? true : false;
44159   {
44160     try {
44161       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
44162     } CALL_CATCH_EXCEPTION(0);
44163   }
44164
44165   jresult = result;
44166   return jresult;
44167 }
44168
44169
44170 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
44171   unsigned int jresult ;
44172   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
44173   unsigned int result;
44174
44175   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
44176   {
44177     try {
44178       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
44179     } CALL_CATCH_EXCEPTION(0);
44180   }
44181
44182   jresult = result;
44183   return jresult;
44184 }
44185
44186
44187 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
44188   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
44189
44190   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
44191   {
44192     try {
44193       delete arg1;
44194     } CALL_CATCH_EXCEPTION();
44195   }
44196
44197 }
44198
44199
44200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
44201   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
44202   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
44203
44204   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
44205   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
44206   if (arg1) (arg1)->scale = *arg2;
44207 }
44208
44209
44210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
44211   void * jresult ;
44212   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
44213   Dali::Toolkit::ClampState2D *result = 0 ;
44214
44215   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
44216   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
44217   jresult = (void *)result;
44218   return jresult;
44219 }
44220
44221
44222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
44223   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
44224   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
44225
44226   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
44227   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
44228   if (arg1) (arg1)->position = *arg2;
44229 }
44230
44231
44232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
44233   void * jresult ;
44234   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
44235   Dali::Toolkit::ClampState2D *result = 0 ;
44236
44237   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
44238   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
44239   jresult = (void *)result;
44240   return jresult;
44241 }
44242
44243
44244 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
44245   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
44246   Dali::Toolkit::ClampState arg2 ;
44247
44248   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
44249   arg2 = (Dali::Toolkit::ClampState)jarg2;
44250   if (arg1) (arg1)->rotation = arg2;
44251 }
44252
44253
44254 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
44255   int jresult ;
44256   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
44257   Dali::Toolkit::ClampState result;
44258
44259   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
44260   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
44261   jresult = (int)result;
44262   return jresult;
44263 }
44264
44265
44266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
44267   void * jresult ;
44268   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
44269
44270   {
44271     try {
44272       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
44273     } CALL_CATCH_EXCEPTION(0);
44274   }
44275
44276   jresult = (void *)result;
44277   return jresult;
44278 }
44279
44280
44281 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
44282   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
44283
44284   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
44285   {
44286     try {
44287       delete arg1;
44288     } CALL_CATCH_EXCEPTION();
44289   }
44290
44291 }
44292
44293
44294 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
44295   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
44296   Dali::Toolkit::SnapType arg2 ;
44297
44298   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
44299   arg2 = (Dali::Toolkit::SnapType)jarg2;
44300   if (arg1) (arg1)->type = arg2;
44301 }
44302
44303
44304 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
44305   int jresult ;
44306   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
44307   Dali::Toolkit::SnapType result;
44308
44309   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
44310   result = (Dali::Toolkit::SnapType) ((arg1)->type);
44311   jresult = (int)result;
44312   return jresult;
44313 }
44314
44315
44316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
44317   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
44318   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
44319
44320   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
44321   arg2 = (Dali::Vector2 *)jarg2;
44322   if (arg1) (arg1)->position = *arg2;
44323 }
44324
44325
44326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
44327   void * jresult ;
44328   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
44329   Dali::Vector2 *result = 0 ;
44330
44331   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
44332   result = (Dali::Vector2 *)& ((arg1)->position);
44333   jresult = (void *)result;
44334   return jresult;
44335 }
44336
44337
44338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
44339   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
44340   float arg2 ;
44341
44342   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
44343   arg2 = (float)jarg2;
44344   if (arg1) (arg1)->duration = arg2;
44345 }
44346
44347
44348 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
44349   float jresult ;
44350   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
44351   float result;
44352
44353   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
44354   result = (float) ((arg1)->duration);
44355   jresult = result;
44356   return jresult;
44357 }
44358
44359
44360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
44361   void * jresult ;
44362   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
44363
44364   {
44365     try {
44366       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
44367     } CALL_CATCH_EXCEPTION(0);
44368   }
44369
44370   jresult = (void *)result;
44371   return jresult;
44372 }
44373
44374
44375 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
44376   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
44377
44378   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
44379   {
44380     try {
44381       delete arg1;
44382     } CALL_CATCH_EXCEPTION();
44383   }
44384
44385 }
44386
44387
44388 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
44389   int jresult ;
44390   int result;
44391
44392   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
44393   jresult = (int)result;
44394   return jresult;
44395 }
44396
44397
44398 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
44399   int jresult ;
44400   int result;
44401
44402   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
44403   jresult = (int)result;
44404   return jresult;
44405 }
44406
44407
44408 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
44409   int jresult ;
44410   int result;
44411
44412   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
44413   jresult = (int)result;
44414   return jresult;
44415 }
44416
44417
44418 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
44419   int jresult ;
44420   int result;
44421
44422   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
44423   jresult = (int)result;
44424   return jresult;
44425 }
44426
44427
44428 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_MODE_get() {
44429   int jresult ;
44430   int result;
44431
44432   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_MODE;
44433   jresult = (int)result;
44434   return jresult;
44435 }
44436
44437 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
44438   int jresult ;
44439   int result;
44440
44441   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
44442   jresult = (int)result;
44443   return jresult;
44444 }
44445
44446
44447 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
44448   int jresult ;
44449   int result;
44450
44451   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
44452   jresult = (int)result;
44453   return jresult;
44454 }
44455
44456
44457 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
44458   int jresult ;
44459   int result;
44460
44461   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
44462   jresult = (int)result;
44463   return jresult;
44464 }
44465
44466
44467 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
44468   int jresult ;
44469   int result;
44470
44471   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
44472   jresult = (int)result;
44473   return jresult;
44474 }
44475
44476
44477 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
44478   int jresult ;
44479   int result;
44480
44481   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
44482   jresult = (int)result;
44483   return jresult;
44484 }
44485
44486
44487 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
44488   int jresult ;
44489   int result;
44490
44491   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
44492   jresult = (int)result;
44493   return jresult;
44494 }
44495
44496
44497 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
44498   int jresult ;
44499   int result;
44500
44501   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
44502   jresult = (int)result;
44503   return jresult;
44504 }
44505
44506
44507 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
44508   int jresult ;
44509   int result;
44510
44511   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
44512   jresult = (int)result;
44513   return jresult;
44514 }
44515
44516
44517 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
44518   int jresult ;
44519   int result;
44520
44521   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
44522   jresult = (int)result;
44523   return jresult;
44524 }
44525
44526
44527 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
44528   int jresult ;
44529   int result;
44530
44531   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
44532   jresult = (int)result;
44533   return jresult;
44534 }
44535
44536
44537 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
44538   int jresult ;
44539   int result;
44540
44541   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
44542   jresult = (int)result;
44543   return jresult;
44544 }
44545
44546
44547 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
44548   int jresult ;
44549   int result;
44550
44551   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
44552   jresult = (int)result;
44553   return jresult;
44554 }
44555
44556
44557 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
44558   int jresult ;
44559   int result;
44560
44561   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
44562   jresult = (int)result;
44563   return jresult;
44564 }
44565
44566
44567 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
44568   int jresult ;
44569   int result;
44570
44571   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
44572   jresult = (int)result;
44573   return jresult;
44574 }
44575
44576
44577 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
44578   int jresult ;
44579   int result;
44580
44581   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
44582   jresult = (int)result;
44583   return jresult;
44584 }
44585
44586
44587 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
44588   int jresult ;
44589   int result;
44590
44591   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
44592   jresult = (int)result;
44593   return jresult;
44594 }
44595
44596
44597 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
44598   int jresult ;
44599   int result;
44600
44601   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
44602   jresult = (int)result;
44603   return jresult;
44604 }
44605
44606
44607 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
44608   int jresult ;
44609   int result;
44610
44611   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
44612   jresult = (int)result;
44613   return jresult;
44614 }
44615
44616
44617 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
44618   int jresult ;
44619   int result;
44620
44621   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
44622   jresult = (int)result;
44623   return jresult;
44624 }
44625
44626
44627 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
44628   int jresult ;
44629   int result;
44630
44631   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
44632   jresult = (int)result;
44633   return jresult;
44634 }
44635
44636
44637 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
44638   int jresult ;
44639   int result;
44640
44641   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
44642   jresult = (int)result;
44643   return jresult;
44644 }
44645
44646
44647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
44648   void * jresult ;
44649   Dali::Toolkit::ScrollView::Property *result = 0 ;
44650
44651   {
44652     try {
44653       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
44654     } CALL_CATCH_EXCEPTION(0);
44655   }
44656
44657   jresult = (void *)result;
44658   return jresult;
44659 }
44660
44661
44662 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
44663   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
44664
44665   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
44666   {
44667     try {
44668       delete arg1;
44669     } CALL_CATCH_EXCEPTION();
44670   }
44671
44672 }
44673
44674
44675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
44676   void * jresult ;
44677   Dali::Toolkit::ScrollView *result = 0 ;
44678
44679   {
44680     try {
44681       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
44682     } CALL_CATCH_EXCEPTION(0);
44683   }
44684
44685   jresult = (void *)result;
44686   return jresult;
44687 }
44688
44689
44690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
44691   void * jresult ;
44692   Dali::Toolkit::ScrollView *arg1 = 0 ;
44693   Dali::Toolkit::ScrollView *result = 0 ;
44694
44695   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44696   if (!arg1) {
44697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
44698     return 0;
44699   }
44700   {
44701     try {
44702       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
44703     } CALL_CATCH_EXCEPTION(0);
44704   }
44705
44706   jresult = (void *)result;
44707   return jresult;
44708 }
44709
44710
44711 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
44712   void * jresult ;
44713   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44714   Dali::Toolkit::ScrollView *arg2 = 0 ;
44715   Dali::Toolkit::ScrollView *result = 0 ;
44716
44717   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44718   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
44719   if (!arg2) {
44720     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
44721     return 0;
44722   }
44723   {
44724     try {
44725       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
44726     } CALL_CATCH_EXCEPTION(0);
44727   }
44728
44729   jresult = (void *)result;
44730   return jresult;
44731 }
44732
44733
44734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
44735   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44736
44737   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44738   {
44739     try {
44740       delete arg1;
44741     } CALL_CATCH_EXCEPTION();
44742   }
44743
44744 }
44745
44746
44747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
44748   void * jresult ;
44749   Dali::Toolkit::ScrollView result;
44750
44751   {
44752     try {
44753       result = Dali::Toolkit::ScrollView::New();
44754     } CALL_CATCH_EXCEPTION(0);
44755   }
44756
44757   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
44758   return jresult;
44759 }
44760
44761
44762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
44763   void * jresult ;
44764   Dali::BaseHandle arg1 ;
44765   Dali::BaseHandle *argp1 ;
44766   Dali::Toolkit::ScrollView result;
44767
44768   argp1 = (Dali::BaseHandle *)jarg1;
44769   if (!argp1) {
44770     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44771     return 0;
44772   }
44773   arg1 = *argp1;
44774   {
44775     try {
44776       result = Dali::Toolkit::ScrollView::DownCast(arg1);
44777     } CALL_CATCH_EXCEPTION(0);
44778   }
44779
44780   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
44781   return jresult;
44782 }
44783
44784
44785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
44786   void * jresult ;
44787   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44788   Dali::AlphaFunction result;
44789
44790   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44791   {
44792     try {
44793       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
44794     } CALL_CATCH_EXCEPTION(0);
44795   }
44796
44797   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
44798   return jresult;
44799 }
44800
44801
44802 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
44803   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44804   Dali::AlphaFunction arg2 ;
44805   Dali::AlphaFunction *argp2 ;
44806
44807   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44808   argp2 = (Dali::AlphaFunction *)jarg2;
44809   if (!argp2) {
44810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
44811     return ;
44812   }
44813   arg2 = *argp2;
44814   {
44815     try {
44816       (arg1)->SetScrollSnapAlphaFunction(arg2);
44817     } CALL_CATCH_EXCEPTION();
44818   }
44819
44820 }
44821
44822
44823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
44824   void * jresult ;
44825   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44826   Dali::AlphaFunction result;
44827
44828   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44829   {
44830     try {
44831       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
44832     } CALL_CATCH_EXCEPTION(0);
44833   }
44834
44835   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
44836   return jresult;
44837 }
44838
44839
44840 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
44841   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44842   Dali::AlphaFunction arg2 ;
44843   Dali::AlphaFunction *argp2 ;
44844
44845   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44846   argp2 = (Dali::AlphaFunction *)jarg2;
44847   if (!argp2) {
44848     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
44849     return ;
44850   }
44851   arg2 = *argp2;
44852   {
44853     try {
44854       (arg1)->SetScrollFlickAlphaFunction(arg2);
44855     } CALL_CATCH_EXCEPTION();
44856   }
44857
44858 }
44859
44860
44861 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
44862   float jresult ;
44863   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44864   float result;
44865
44866   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44867   {
44868     try {
44869       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
44870     } CALL_CATCH_EXCEPTION(0);
44871   }
44872
44873   jresult = result;
44874   return jresult;
44875 }
44876
44877
44878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
44879   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44880   float arg2 ;
44881
44882   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44883   arg2 = (float)jarg2;
44884   {
44885     try {
44886       (arg1)->SetScrollSnapDuration(arg2);
44887     } CALL_CATCH_EXCEPTION();
44888   }
44889
44890 }
44891
44892
44893 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
44894   float jresult ;
44895   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44896   float result;
44897
44898   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44899   {
44900     try {
44901       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
44902     } CALL_CATCH_EXCEPTION(0);
44903   }
44904
44905   jresult = result;
44906   return jresult;
44907 }
44908
44909
44910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
44911   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44912   float arg2 ;
44913
44914   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44915   arg2 = (float)jarg2;
44916   {
44917     try {
44918       (arg1)->SetScrollFlickDuration(arg2);
44919     } CALL_CATCH_EXCEPTION();
44920   }
44921
44922 }
44923
44924
44925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
44926   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44927   Dali::Toolkit::RulerPtr arg2 ;
44928   Dali::Toolkit::RulerPtr *argp2 ;
44929
44930   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44931   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
44932   if (!argp2) {
44933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
44934     return ;
44935   }
44936   arg2 = *argp2;
44937   {
44938     try {
44939       (arg1)->SetRulerX(arg2);
44940     } CALL_CATCH_EXCEPTION();
44941   }
44942
44943 }
44944
44945
44946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
44947   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44948   Dali::Toolkit::RulerPtr arg2 ;
44949   Dali::Toolkit::RulerPtr *argp2 ;
44950
44951   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44952   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
44953   if (!argp2) {
44954     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
44955     return ;
44956   }
44957   arg2 = *argp2;
44958   {
44959     try {
44960       (arg1)->SetRulerY(arg2);
44961     } CALL_CATCH_EXCEPTION();
44962   }
44963
44964 }
44965
44966
44967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
44968   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44969   bool arg2 ;
44970
44971   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44972   arg2 = jarg2 ? true : false;
44973   {
44974     try {
44975       (arg1)->SetScrollSensitive(arg2);
44976     } CALL_CATCH_EXCEPTION();
44977   }
44978
44979 }
44980
44981
44982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
44983   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
44984   float arg2 ;
44985   float arg3 ;
44986
44987   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
44988   arg2 = (float)jarg2;
44989   arg3 = (float)jarg3;
44990   {
44991     try {
44992       (arg1)->SetMaxOvershoot(arg2,arg3);
44993     } CALL_CATCH_EXCEPTION();
44994   }
44995
44996 }
44997
44998
44999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
45000   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45001   Dali::AlphaFunction arg2 ;
45002   Dali::AlphaFunction *argp2 ;
45003
45004   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45005   argp2 = (Dali::AlphaFunction *)jarg2;
45006   if (!argp2) {
45007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
45008     return ;
45009   }
45010   arg2 = *argp2;
45011   {
45012     try {
45013       (arg1)->SetSnapOvershootAlphaFunction(arg2);
45014     } CALL_CATCH_EXCEPTION();
45015   }
45016
45017 }
45018
45019
45020 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
45021   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45022   float arg2 ;
45023
45024   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45025   arg2 = (float)jarg2;
45026   {
45027     try {
45028       (arg1)->SetSnapOvershootDuration(arg2);
45029     } CALL_CATCH_EXCEPTION();
45030   }
45031
45032 }
45033
45034
45035 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
45036   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45037   bool arg2 ;
45038
45039   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45040   arg2 = jarg2 ? true : false;
45041   {
45042     try {
45043       (arg1)->SetActorAutoSnap(arg2);
45044     } CALL_CATCH_EXCEPTION();
45045   }
45046
45047 }
45048
45049
45050 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
45051   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45052   bool arg2 ;
45053
45054   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45055   arg2 = jarg2 ? true : false;
45056   {
45057     try {
45058       (arg1)->SetWrapMode(arg2);
45059     } CALL_CATCH_EXCEPTION();
45060   }
45061
45062 }
45063
45064
45065 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
45066   int jresult ;
45067   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45068   int result;
45069
45070   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45071   {
45072     try {
45073       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
45074     } CALL_CATCH_EXCEPTION(0);
45075   }
45076
45077   jresult = result;
45078   return jresult;
45079 }
45080
45081
45082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
45083   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45084   int arg2 ;
45085
45086   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45087   arg2 = (int)jarg2;
45088   {
45089     try {
45090       (arg1)->SetScrollUpdateDistance(arg2);
45091     } CALL_CATCH_EXCEPTION();
45092   }
45093
45094 }
45095
45096
45097 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
45098   unsigned int jresult ;
45099   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45100   bool result;
45101
45102   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45103   {
45104     try {
45105       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
45106     } CALL_CATCH_EXCEPTION(0);
45107   }
45108
45109   jresult = result;
45110   return jresult;
45111 }
45112
45113
45114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
45115   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45116   bool arg2 ;
45117
45118   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45119   arg2 = jarg2 ? true : false;
45120   {
45121     try {
45122       (arg1)->SetAxisAutoLock(arg2);
45123     } CALL_CATCH_EXCEPTION();
45124   }
45125
45126 }
45127
45128
45129 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
45130   float jresult ;
45131   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45132   float result;
45133
45134   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45135   {
45136     try {
45137       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
45138     } CALL_CATCH_EXCEPTION(0);
45139   }
45140
45141   jresult = result;
45142   return jresult;
45143 }
45144
45145
45146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
45147   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45148   float arg2 ;
45149
45150   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45151   arg2 = (float)jarg2;
45152   {
45153     try {
45154       (arg1)->SetAxisAutoLockGradient(arg2);
45155     } CALL_CATCH_EXCEPTION();
45156   }
45157
45158 }
45159
45160
45161 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
45162   float jresult ;
45163   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45164   float result;
45165
45166   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45167   {
45168     try {
45169       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
45170     } CALL_CATCH_EXCEPTION(0);
45171   }
45172
45173   jresult = result;
45174   return jresult;
45175 }
45176
45177
45178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
45179   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45180   float arg2 ;
45181
45182   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45183   arg2 = (float)jarg2;
45184   {
45185     try {
45186       (arg1)->SetFrictionCoefficient(arg2);
45187     } CALL_CATCH_EXCEPTION();
45188   }
45189
45190 }
45191
45192
45193 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
45194   float jresult ;
45195   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45196   float result;
45197
45198   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45199   {
45200     try {
45201       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
45202     } CALL_CATCH_EXCEPTION(0);
45203   }
45204
45205   jresult = result;
45206   return jresult;
45207 }
45208
45209
45210 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
45211   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45212   float arg2 ;
45213
45214   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45215   arg2 = (float)jarg2;
45216   {
45217     try {
45218       (arg1)->SetFlickSpeedCoefficient(arg2);
45219     } CALL_CATCH_EXCEPTION();
45220   }
45221
45222 }
45223
45224
45225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
45226   void * jresult ;
45227   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45228   Dali::Vector2 result;
45229
45230   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45231   {
45232     try {
45233       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
45234     } CALL_CATCH_EXCEPTION(0);
45235   }
45236
45237   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
45238   return jresult;
45239 }
45240
45241
45242 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
45243   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45244   Dali::Vector2 *arg2 = 0 ;
45245
45246   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45247   arg2 = (Dali::Vector2 *)jarg2;
45248   if (!arg2) {
45249     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
45250     return ;
45251   }
45252   {
45253     try {
45254       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
45255     } CALL_CATCH_EXCEPTION();
45256   }
45257
45258 }
45259
45260
45261 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
45262   float jresult ;
45263   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45264   float result;
45265
45266   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45267   {
45268     try {
45269       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
45270     } CALL_CATCH_EXCEPTION(0);
45271   }
45272
45273   jresult = result;
45274   return jresult;
45275 }
45276
45277
45278 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
45279   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45280   float arg2 ;
45281
45282   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45283   arg2 = (float)jarg2;
45284   {
45285     try {
45286       (arg1)->SetMinimumSpeedForFlick(arg2);
45287     } CALL_CATCH_EXCEPTION();
45288   }
45289
45290 }
45291
45292
45293 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
45294   float jresult ;
45295   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45296   float result;
45297
45298   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45299   {
45300     try {
45301       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
45302     } CALL_CATCH_EXCEPTION(0);
45303   }
45304
45305   jresult = result;
45306   return jresult;
45307 }
45308
45309
45310 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
45311   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45312   float arg2 ;
45313
45314   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45315   arg2 = (float)jarg2;
45316   {
45317     try {
45318       (arg1)->SetMaxFlickSpeed(arg2);
45319     } CALL_CATCH_EXCEPTION();
45320   }
45321
45322 }
45323
45324
45325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
45326   void * jresult ;
45327   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45328   Dali::Vector2 result;
45329
45330   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45331   {
45332     try {
45333       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
45334     } CALL_CATCH_EXCEPTION(0);
45335   }
45336
45337   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
45338   return jresult;
45339 }
45340
45341
45342 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
45343   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45344   Dali::Vector2 arg2 ;
45345   Dali::Vector2 *argp2 ;
45346
45347   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45348   argp2 = (Dali::Vector2 *)jarg2;
45349   if (!argp2) {
45350     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
45351     return ;
45352   }
45353   arg2 = *argp2;
45354   {
45355     try {
45356       (arg1)->SetWheelScrollDistanceStep(arg2);
45357     } CALL_CATCH_EXCEPTION();
45358   }
45359
45360 }
45361
45362
45363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
45364   void * jresult ;
45365   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45366   Dali::Vector2 result;
45367
45368   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45369   {
45370     try {
45371       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
45372     } CALL_CATCH_EXCEPTION(0);
45373   }
45374
45375   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
45376   return jresult;
45377 }
45378
45379
45380 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
45381   unsigned int jresult ;
45382   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45383   unsigned int result;
45384
45385   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45386   {
45387     try {
45388       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
45389     } CALL_CATCH_EXCEPTION(0);
45390   }
45391
45392   jresult = result;
45393   return jresult;
45394 }
45395
45396
45397 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
45398   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45399   Dali::Vector2 *arg2 = 0 ;
45400
45401   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45402   arg2 = (Dali::Vector2 *)jarg2;
45403   if (!arg2) {
45404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
45405     return ;
45406   }
45407   {
45408     try {
45409       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
45410     } CALL_CATCH_EXCEPTION();
45411   }
45412
45413 }
45414
45415
45416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
45417   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45418   Dali::Vector2 *arg2 = 0 ;
45419   float arg3 ;
45420
45421   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45422   arg2 = (Dali::Vector2 *)jarg2;
45423   if (!arg2) {
45424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
45425     return ;
45426   }
45427   arg3 = (float)jarg3;
45428   {
45429     try {
45430       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
45431     } CALL_CATCH_EXCEPTION();
45432   }
45433
45434 }
45435
45436
45437 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
45438   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45439   Dali::Vector2 *arg2 = 0 ;
45440   float arg3 ;
45441   Dali::AlphaFunction arg4 ;
45442   Dali::AlphaFunction *argp4 ;
45443
45444   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45445   arg2 = (Dali::Vector2 *)jarg2;
45446   if (!arg2) {
45447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
45448     return ;
45449   }
45450   arg3 = (float)jarg3;
45451   argp4 = (Dali::AlphaFunction *)jarg4;
45452   if (!argp4) {
45453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
45454     return ;
45455   }
45456   arg4 = *argp4;
45457   {
45458     try {
45459       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
45460     } CALL_CATCH_EXCEPTION();
45461   }
45462
45463 }
45464
45465
45466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
45467   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45468   Dali::Vector2 *arg2 = 0 ;
45469   float arg3 ;
45470   Dali::Toolkit::DirectionBias arg4 ;
45471   Dali::Toolkit::DirectionBias arg5 ;
45472
45473   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45474   arg2 = (Dali::Vector2 *)jarg2;
45475   if (!arg2) {
45476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
45477     return ;
45478   }
45479   arg3 = (float)jarg3;
45480   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
45481   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
45482   {
45483     try {
45484       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
45485     } CALL_CATCH_EXCEPTION();
45486   }
45487
45488 }
45489
45490
45491 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
45492   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45493   Dali::Vector2 *arg2 = 0 ;
45494   float arg3 ;
45495   Dali::AlphaFunction arg4 ;
45496   Dali::Toolkit::DirectionBias arg5 ;
45497   Dali::Toolkit::DirectionBias arg6 ;
45498   Dali::AlphaFunction *argp4 ;
45499
45500   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45501   arg2 = (Dali::Vector2 *)jarg2;
45502   if (!arg2) {
45503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
45504     return ;
45505   }
45506   arg3 = (float)jarg3;
45507   argp4 = (Dali::AlphaFunction *)jarg4;
45508   if (!argp4) {
45509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
45510     return ;
45511   }
45512   arg4 = *argp4;
45513   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
45514   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
45515   {
45516     try {
45517       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
45518     } CALL_CATCH_EXCEPTION();
45519   }
45520
45521 }
45522
45523
45524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
45525   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45526   unsigned int arg2 ;
45527
45528   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45529   arg2 = (unsigned int)jarg2;
45530   {
45531     try {
45532       (arg1)->ScrollTo(arg2);
45533     } CALL_CATCH_EXCEPTION();
45534   }
45535
45536 }
45537
45538
45539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
45540   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45541   unsigned int arg2 ;
45542   float arg3 ;
45543
45544   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45545   arg2 = (unsigned int)jarg2;
45546   arg3 = (float)jarg3;
45547   {
45548     try {
45549       (arg1)->ScrollTo(arg2,arg3);
45550     } CALL_CATCH_EXCEPTION();
45551   }
45552
45553 }
45554
45555
45556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
45557   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45558   unsigned int arg2 ;
45559   float arg3 ;
45560   Dali::Toolkit::DirectionBias arg4 ;
45561
45562   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45563   arg2 = (unsigned int)jarg2;
45564   arg3 = (float)jarg3;
45565   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
45566   {
45567     try {
45568       (arg1)->ScrollTo(arg2,arg3,arg4);
45569     } CALL_CATCH_EXCEPTION();
45570   }
45571
45572 }
45573
45574
45575 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
45576   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45577   Dali::Actor *arg2 = 0 ;
45578
45579   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45580   arg2 = (Dali::Actor *)jarg2;
45581   if (!arg2) {
45582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
45583     return ;
45584   }
45585   {
45586     try {
45587       (arg1)->ScrollTo(*arg2);
45588     } CALL_CATCH_EXCEPTION();
45589   }
45590
45591 }
45592
45593
45594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
45595   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45596   Dali::Actor *arg2 = 0 ;
45597   float arg3 ;
45598
45599   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45600   arg2 = (Dali::Actor *)jarg2;
45601   if (!arg2) {
45602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
45603     return ;
45604   }
45605   arg3 = (float)jarg3;
45606   {
45607     try {
45608       (arg1)->ScrollTo(*arg2,arg3);
45609     } CALL_CATCH_EXCEPTION();
45610   }
45611
45612 }
45613
45614
45615 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
45616   unsigned int jresult ;
45617   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45618   bool result;
45619
45620   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45621   {
45622     try {
45623       result = (bool)(arg1)->ScrollToSnapPoint();
45624     } CALL_CATCH_EXCEPTION(0);
45625   }
45626
45627   jresult = result;
45628   return jresult;
45629 }
45630
45631
45632 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
45633   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45634   Dali::Constraint arg2 ;
45635   Dali::Constraint *argp2 ;
45636
45637   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45638   argp2 = (Dali::Constraint *)jarg2;
45639   if (!argp2) {
45640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
45641     return ;
45642   }
45643   arg2 = *argp2;
45644   {
45645     try {
45646       (arg1)->ApplyConstraintToChildren(arg2);
45647     } CALL_CATCH_EXCEPTION();
45648   }
45649
45650 }
45651
45652
45653 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
45654   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45655
45656   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45657   {
45658     try {
45659       (arg1)->RemoveConstraintsFromChildren();
45660     } CALL_CATCH_EXCEPTION();
45661   }
45662
45663 }
45664
45665
45666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
45667   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45668   Dali::Toolkit::ScrollViewEffect arg2 ;
45669   Dali::Toolkit::ScrollViewEffect *argp2 ;
45670
45671   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45672   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
45673   if (!argp2) {
45674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
45675     return ;
45676   }
45677   arg2 = *argp2;
45678   {
45679     try {
45680       (arg1)->ApplyEffect(arg2);
45681     } CALL_CATCH_EXCEPTION();
45682   }
45683
45684 }
45685
45686
45687 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
45688   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45689   Dali::Toolkit::ScrollViewEffect arg2 ;
45690   Dali::Toolkit::ScrollViewEffect *argp2 ;
45691
45692   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45693   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
45694   if (!argp2) {
45695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
45696     return ;
45697   }
45698   arg2 = *argp2;
45699   {
45700     try {
45701       (arg1)->RemoveEffect(arg2);
45702     } CALL_CATCH_EXCEPTION();
45703   }
45704
45705 }
45706
45707
45708 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
45709   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45710
45711   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45712   {
45713     try {
45714       (arg1)->RemoveAllEffects();
45715     } CALL_CATCH_EXCEPTION();
45716   }
45717
45718 }
45719
45720
45721 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
45722   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45723   Dali::Actor arg2 ;
45724   Dali::Actor *argp2 ;
45725
45726   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45727   argp2 = (Dali::Actor *)jarg2;
45728   if (!argp2) {
45729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
45730     return ;
45731   }
45732   arg2 = *argp2;
45733   {
45734     try {
45735       (arg1)->BindActor(arg2);
45736     } CALL_CATCH_EXCEPTION();
45737   }
45738
45739 }
45740
45741
45742 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
45743   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45744   Dali::Actor arg2 ;
45745   Dali::Actor *argp2 ;
45746
45747   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45748   argp2 = (Dali::Actor *)jarg2;
45749   if (!argp2) {
45750     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
45751     return ;
45752   }
45753   arg2 = *argp2;
45754   {
45755     try {
45756       (arg1)->UnbindActor(arg2);
45757     } CALL_CATCH_EXCEPTION();
45758   }
45759
45760 }
45761
45762
45763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
45764   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45765   Dali::Radian arg2 ;
45766   Dali::Radian arg3 ;
45767   Dali::Radian *argp2 ;
45768   Dali::Radian *argp3 ;
45769
45770   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45771   argp2 = (Dali::Radian *)jarg2;
45772   if (!argp2) {
45773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
45774     return ;
45775   }
45776   arg2 = *argp2;
45777   argp3 = (Dali::Radian *)jarg3;
45778   if (!argp3) {
45779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
45780     return ;
45781   }
45782   arg3 = *argp3;
45783   {
45784     try {
45785       (arg1)->SetScrollingDirection(arg2,arg3);
45786     } CALL_CATCH_EXCEPTION();
45787   }
45788
45789 }
45790
45791
45792 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
45793   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45794   Dali::Radian arg2 ;
45795   Dali::Radian *argp2 ;
45796
45797   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45798   argp2 = (Dali::Radian *)jarg2;
45799   if (!argp2) {
45800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
45801     return ;
45802   }
45803   arg2 = *argp2;
45804   {
45805     try {
45806       (arg1)->SetScrollingDirection(arg2);
45807     } CALL_CATCH_EXCEPTION();
45808   }
45809
45810 }
45811
45812
45813 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
45814   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45815   Dali::Radian arg2 ;
45816   Dali::Radian *argp2 ;
45817
45818   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45819   argp2 = (Dali::Radian *)jarg2;
45820   if (!argp2) {
45821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
45822     return ;
45823   }
45824   arg2 = *argp2;
45825   {
45826     try {
45827       (arg1)->RemoveScrollingDirection(arg2);
45828     } CALL_CATCH_EXCEPTION();
45829   }
45830
45831 }
45832
45833
45834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
45835   void * jresult ;
45836   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
45837   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
45838
45839   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
45840   {
45841     try {
45842       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
45843     } CALL_CATCH_EXCEPTION(0);
45844   }
45845
45846   jresult = (void *)result;
45847   return jresult;
45848 }
45849
45850
45851 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
45852   int jresult ;
45853   int result;
45854
45855   result = (int)Dali::Toolkit::TableView::Property::ROWS;
45856   jresult = (int)result;
45857   return jresult;
45858 }
45859
45860
45861 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
45862   int jresult ;
45863   int result;
45864
45865   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
45866   jresult = (int)result;
45867   return jresult;
45868 }
45869
45870
45871 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
45872   int jresult ;
45873   int result;
45874
45875   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
45876   jresult = (int)result;
45877   return jresult;
45878 }
45879
45880
45881 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
45882   int jresult ;
45883   int result;
45884
45885   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
45886   jresult = (int)result;
45887   return jresult;
45888 }
45889
45890
45891 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
45892   int jresult ;
45893   int result;
45894
45895   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
45896   jresult = (int)result;
45897   return jresult;
45898 }
45899
45900
45901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
45902   void * jresult ;
45903   Dali::Toolkit::TableView::Property *result = 0 ;
45904
45905   {
45906     try {
45907       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
45908     } CALL_CATCH_EXCEPTION(0);
45909   }
45910
45911   jresult = (void *)result;
45912   return jresult;
45913 }
45914
45915
45916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
45917   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
45918
45919   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
45920   {
45921     try {
45922       delete arg1;
45923     } CALL_CATCH_EXCEPTION();
45924   }
45925
45926 }
45927
45928
45929 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
45930   int jresult ;
45931   int result;
45932
45933   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
45934   jresult = (int)result;
45935   return jresult;
45936 }
45937
45938
45939 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
45940   int jresult ;
45941   int result;
45942
45943   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
45944   jresult = (int)result;
45945   return jresult;
45946 }
45947
45948
45949 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
45950   int jresult ;
45951   int result;
45952
45953   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
45954   jresult = (int)result;
45955   return jresult;
45956 }
45957
45958
45959 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
45960   int jresult ;
45961   int result;
45962
45963   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
45964   jresult = (int)result;
45965   return jresult;
45966 }
45967
45968
45969 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
45970   int jresult ;
45971   int result;
45972
45973   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
45974   jresult = (int)result;
45975   return jresult;
45976 }
45977
45978
45979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
45980   void * jresult ;
45981   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
45982
45983   {
45984     try {
45985       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
45986     } CALL_CATCH_EXCEPTION(0);
45987   }
45988
45989   jresult = (void *)result;
45990   return jresult;
45991 }
45992
45993
45994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
45995   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
45996
45997   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
45998   {
45999     try {
46000       delete arg1;
46001     } CALL_CATCH_EXCEPTION();
46002   }
46003
46004 }
46005
46006
46007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
46008   void * jresult ;
46009   unsigned int arg1 ;
46010   unsigned int arg2 ;
46011   unsigned int arg3 ;
46012   unsigned int arg4 ;
46013   Dali::Toolkit::TableView::CellPosition *result = 0 ;
46014
46015   arg1 = (unsigned int)jarg1;
46016   arg2 = (unsigned int)jarg2;
46017   arg3 = (unsigned int)jarg3;
46018   arg4 = (unsigned int)jarg4;
46019   {
46020     try {
46021       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
46022     } CALL_CATCH_EXCEPTION(0);
46023   }
46024
46025   jresult = (void *)result;
46026   return jresult;
46027 }
46028
46029
46030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
46031   void * jresult ;
46032   unsigned int arg1 ;
46033   unsigned int arg2 ;
46034   unsigned int arg3 ;
46035   Dali::Toolkit::TableView::CellPosition *result = 0 ;
46036
46037   arg1 = (unsigned int)jarg1;
46038   arg2 = (unsigned int)jarg2;
46039   arg3 = (unsigned int)jarg3;
46040   {
46041     try {
46042       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
46043     } CALL_CATCH_EXCEPTION(0);
46044   }
46045
46046   jresult = (void *)result;
46047   return jresult;
46048 }
46049
46050
46051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
46052   void * jresult ;
46053   unsigned int arg1 ;
46054   unsigned int arg2 ;
46055   Dali::Toolkit::TableView::CellPosition *result = 0 ;
46056
46057   arg1 = (unsigned int)jarg1;
46058   arg2 = (unsigned int)jarg2;
46059   {
46060     try {
46061       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
46062     } CALL_CATCH_EXCEPTION(0);
46063   }
46064
46065   jresult = (void *)result;
46066   return jresult;
46067 }
46068
46069
46070 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
46071   void * jresult ;
46072   unsigned int arg1 ;
46073   Dali::Toolkit::TableView::CellPosition *result = 0 ;
46074
46075   arg1 = (unsigned int)jarg1;
46076   {
46077     try {
46078       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
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_4() {
46088   void * jresult ;
46089   Dali::Toolkit::TableView::CellPosition *result = 0 ;
46090
46091   {
46092     try {
46093       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
46094     } CALL_CATCH_EXCEPTION(0);
46095   }
46096
46097   jresult = (void *)result;
46098   return jresult;
46099 }
46100
46101
46102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
46103   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
46104   unsigned int arg2 ;
46105
46106   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
46107   arg2 = (unsigned int)jarg2;
46108   if (arg1) (arg1)->rowIndex = arg2;
46109 }
46110
46111
46112 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
46113   unsigned int jresult ;
46114   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
46115   unsigned int result;
46116
46117   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
46118   result = (unsigned int) ((arg1)->rowIndex);
46119   jresult = result;
46120   return jresult;
46121 }
46122
46123
46124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
46125   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
46126   unsigned int arg2 ;
46127
46128   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
46129   arg2 = (unsigned int)jarg2;
46130   if (arg1) (arg1)->columnIndex = arg2;
46131 }
46132
46133
46134 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
46135   unsigned int jresult ;
46136   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
46137   unsigned int result;
46138
46139   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
46140   result = (unsigned int) ((arg1)->columnIndex);
46141   jresult = result;
46142   return jresult;
46143 }
46144
46145
46146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
46147   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
46148   unsigned int arg2 ;
46149
46150   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
46151   arg2 = (unsigned int)jarg2;
46152   if (arg1) (arg1)->rowSpan = arg2;
46153 }
46154
46155
46156 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
46157   unsigned int jresult ;
46158   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
46159   unsigned int result;
46160
46161   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
46162   result = (unsigned int) ((arg1)->rowSpan);
46163   jresult = result;
46164   return jresult;
46165 }
46166
46167
46168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
46169   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
46170   unsigned int arg2 ;
46171
46172   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
46173   arg2 = (unsigned int)jarg2;
46174   if (arg1) (arg1)->columnSpan = arg2;
46175 }
46176
46177
46178 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
46179   unsigned int jresult ;
46180   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
46181   unsigned int result;
46182
46183   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
46184   result = (unsigned int) ((arg1)->columnSpan);
46185   jresult = result;
46186   return jresult;
46187 }
46188
46189
46190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
46191   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
46192
46193   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
46194   {
46195     try {
46196       delete arg1;
46197     } CALL_CATCH_EXCEPTION();
46198   }
46199
46200 }
46201
46202
46203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
46204   void * jresult ;
46205   Dali::Toolkit::TableView *result = 0 ;
46206
46207   {
46208     try {
46209       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
46210     } CALL_CATCH_EXCEPTION(0);
46211   }
46212
46213   jresult = (void *)result;
46214   return jresult;
46215 }
46216
46217
46218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
46219   void * jresult ;
46220   Dali::Toolkit::TableView *arg1 = 0 ;
46221   Dali::Toolkit::TableView *result = 0 ;
46222
46223   arg1 = (Dali::Toolkit::TableView *)jarg1;
46224   if (!arg1) {
46225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
46226     return 0;
46227   }
46228   {
46229     try {
46230       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
46231     } CALL_CATCH_EXCEPTION(0);
46232   }
46233
46234   jresult = (void *)result;
46235   return jresult;
46236 }
46237
46238
46239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
46240   void * jresult ;
46241   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46242   Dali::Toolkit::TableView *arg2 = 0 ;
46243   Dali::Toolkit::TableView *result = 0 ;
46244
46245   arg1 = (Dali::Toolkit::TableView *)jarg1;
46246   arg2 = (Dali::Toolkit::TableView *)jarg2;
46247   if (!arg2) {
46248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
46249     return 0;
46250   }
46251   {
46252     try {
46253       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
46254     } CALL_CATCH_EXCEPTION(0);
46255   }
46256
46257   jresult = (void *)result;
46258   return jresult;
46259 }
46260
46261
46262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
46263   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46264
46265   arg1 = (Dali::Toolkit::TableView *)jarg1;
46266   {
46267     try {
46268       delete arg1;
46269     } CALL_CATCH_EXCEPTION();
46270   }
46271
46272 }
46273
46274
46275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
46276   void * jresult ;
46277   unsigned int arg1 ;
46278   unsigned int arg2 ;
46279   Dali::Toolkit::TableView result;
46280
46281   arg1 = (unsigned int)jarg1;
46282   arg2 = (unsigned int)jarg2;
46283   {
46284     try {
46285       result = Dali::Toolkit::TableView::New(arg1,arg2);
46286     } CALL_CATCH_EXCEPTION(0);
46287   }
46288
46289   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
46290   return jresult;
46291 }
46292
46293
46294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
46295   void * jresult ;
46296   Dali::BaseHandle arg1 ;
46297   Dali::BaseHandle *argp1 ;
46298   Dali::Toolkit::TableView result;
46299
46300   argp1 = (Dali::BaseHandle *)jarg1;
46301   if (!argp1) {
46302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
46303     return 0;
46304   }
46305   arg1 = *argp1;
46306   {
46307     try {
46308       result = Dali::Toolkit::TableView::DownCast(arg1);
46309     } CALL_CATCH_EXCEPTION(0);
46310   }
46311
46312   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
46313   return jresult;
46314 }
46315
46316
46317 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
46318   unsigned int jresult ;
46319   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46320   Dali::Actor arg2 ;
46321   Dali::Toolkit::TableView::CellPosition arg3 ;
46322   Dali::Actor *argp2 ;
46323   Dali::Toolkit::TableView::CellPosition *argp3 ;
46324   bool result;
46325
46326   arg1 = (Dali::Toolkit::TableView *)jarg1;
46327   argp2 = (Dali::Actor *)jarg2;
46328   if (!argp2) {
46329     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
46330     return 0;
46331   }
46332   arg2 = *argp2;
46333   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
46334   if (!argp3) {
46335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
46336     return 0;
46337   }
46338   arg3 = *argp3;
46339   {
46340     try {
46341       result = (bool)(arg1)->AddChild(arg2,arg3);
46342     } CALL_CATCH_EXCEPTION(0);
46343   }
46344
46345   jresult = result;
46346   return jresult;
46347 }
46348
46349
46350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
46351   void * jresult ;
46352   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46353   Dali::Toolkit::TableView::CellPosition arg2 ;
46354   Dali::Toolkit::TableView::CellPosition *argp2 ;
46355   Dali::Actor result;
46356
46357   arg1 = (Dali::Toolkit::TableView *)jarg1;
46358   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
46359   if (!argp2) {
46360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
46361     return 0;
46362   }
46363   arg2 = *argp2;
46364   {
46365     try {
46366       result = (arg1)->GetChildAt(arg2);
46367     } CALL_CATCH_EXCEPTION(0);
46368   }
46369
46370   jresult = new Dali::Actor((const Dali::Actor &)result);
46371   return jresult;
46372 }
46373
46374
46375 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
46376   void * jresult ;
46377   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46378   Dali::Toolkit::TableView::CellPosition arg2 ;
46379   Dali::Toolkit::TableView::CellPosition *argp2 ;
46380   Dali::Actor result;
46381
46382   arg1 = (Dali::Toolkit::TableView *)jarg1;
46383   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
46384   if (!argp2) {
46385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
46386     return 0;
46387   }
46388   arg2 = *argp2;
46389   {
46390     try {
46391       result = (arg1)->RemoveChildAt(arg2);
46392     } CALL_CATCH_EXCEPTION(0);
46393   }
46394
46395   jresult = new Dali::Actor((const Dali::Actor &)result);
46396   return jresult;
46397 }
46398
46399
46400 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
46401   unsigned int jresult ;
46402   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46403   Dali::Actor arg2 ;
46404   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
46405   Dali::Actor *argp2 ;
46406   bool result;
46407
46408   arg1 = (Dali::Toolkit::TableView *)jarg1;
46409   argp2 = (Dali::Actor *)jarg2;
46410   if (!argp2) {
46411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
46412     return 0;
46413   }
46414   arg2 = *argp2;
46415   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
46416   if (!arg3) {
46417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
46418     return 0;
46419   }
46420   {
46421     try {
46422       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
46423     } CALL_CATCH_EXCEPTION(0);
46424   }
46425
46426   jresult = result;
46427   return jresult;
46428 }
46429
46430
46431 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
46432   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46433   unsigned int arg2 ;
46434
46435   arg1 = (Dali::Toolkit::TableView *)jarg1;
46436   arg2 = (unsigned int)jarg2;
46437   {
46438     try {
46439       (arg1)->InsertRow(arg2);
46440     } CALL_CATCH_EXCEPTION();
46441   }
46442
46443 }
46444
46445
46446 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
46447   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46448   unsigned int arg2 ;
46449
46450   arg1 = (Dali::Toolkit::TableView *)jarg1;
46451   arg2 = (unsigned int)jarg2;
46452   {
46453     try {
46454       (arg1)->DeleteRow(arg2);
46455     } CALL_CATCH_EXCEPTION();
46456   }
46457
46458 }
46459
46460
46461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
46462   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46463   unsigned int arg2 ;
46464   std::vector< Dali::Actor > *arg3 = 0 ;
46465
46466   arg1 = (Dali::Toolkit::TableView *)jarg1;
46467   arg2 = (unsigned int)jarg2;
46468   arg3 = (std::vector< Dali::Actor > *)jarg3;
46469   if (!arg3) {
46470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
46471     return ;
46472   }
46473   {
46474     try {
46475       (arg1)->DeleteRow(arg2,*arg3);
46476     } CALL_CATCH_EXCEPTION();
46477   }
46478
46479 }
46480
46481
46482 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
46483   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46484   unsigned int arg2 ;
46485
46486   arg1 = (Dali::Toolkit::TableView *)jarg1;
46487   arg2 = (unsigned int)jarg2;
46488   {
46489     try {
46490       (arg1)->InsertColumn(arg2);
46491     } CALL_CATCH_EXCEPTION();
46492   }
46493
46494 }
46495
46496
46497 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
46498   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46499   unsigned int arg2 ;
46500
46501   arg1 = (Dali::Toolkit::TableView *)jarg1;
46502   arg2 = (unsigned int)jarg2;
46503   {
46504     try {
46505       (arg1)->DeleteColumn(arg2);
46506     } CALL_CATCH_EXCEPTION();
46507   }
46508
46509 }
46510
46511
46512 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
46513   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46514   unsigned int arg2 ;
46515   std::vector< Dali::Actor > *arg3 = 0 ;
46516
46517   arg1 = (Dali::Toolkit::TableView *)jarg1;
46518   arg2 = (unsigned int)jarg2;
46519   arg3 = (std::vector< Dali::Actor > *)jarg3;
46520   if (!arg3) {
46521     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
46522     return ;
46523   }
46524   {
46525     try {
46526       (arg1)->DeleteColumn(arg2,*arg3);
46527     } CALL_CATCH_EXCEPTION();
46528   }
46529
46530 }
46531
46532
46533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
46534   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46535   unsigned int arg2 ;
46536   unsigned int arg3 ;
46537
46538   arg1 = (Dali::Toolkit::TableView *)jarg1;
46539   arg2 = (unsigned int)jarg2;
46540   arg3 = (unsigned int)jarg3;
46541   {
46542     try {
46543       (arg1)->Resize(arg2,arg3);
46544     } CALL_CATCH_EXCEPTION();
46545   }
46546
46547 }
46548
46549
46550 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
46551   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46552   unsigned int arg2 ;
46553   unsigned int arg3 ;
46554   std::vector< Dali::Actor > *arg4 = 0 ;
46555
46556   arg1 = (Dali::Toolkit::TableView *)jarg1;
46557   arg2 = (unsigned int)jarg2;
46558   arg3 = (unsigned int)jarg3;
46559   arg4 = (std::vector< Dali::Actor > *)jarg4;
46560   if (!arg4) {
46561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
46562     return ;
46563   }
46564   {
46565     try {
46566       (arg1)->Resize(arg2,arg3,*arg4);
46567     } CALL_CATCH_EXCEPTION();
46568   }
46569
46570 }
46571
46572
46573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
46574   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46575   Dali::Size arg2 ;
46576   Dali::Size *argp2 ;
46577
46578   arg1 = (Dali::Toolkit::TableView *)jarg1;
46579   argp2 = (Dali::Size *)jarg2;
46580   if (!argp2) {
46581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
46582     return ;
46583   }
46584   arg2 = *argp2;
46585   {
46586     try {
46587       (arg1)->SetCellPadding(arg2);
46588     } CALL_CATCH_EXCEPTION();
46589   }
46590
46591 }
46592
46593
46594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
46595   void * jresult ;
46596   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46597   Dali::Size result;
46598
46599   arg1 = (Dali::Toolkit::TableView *)jarg1;
46600   {
46601     try {
46602       result = (arg1)->GetCellPadding();
46603     } CALL_CATCH_EXCEPTION(0);
46604   }
46605
46606   jresult = new Dali::Size((const Dali::Size &)result);
46607   return jresult;
46608 }
46609
46610
46611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
46612   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46613   unsigned int arg2 ;
46614
46615   arg1 = (Dali::Toolkit::TableView *)jarg1;
46616   arg2 = (unsigned int)jarg2;
46617   {
46618     try {
46619       (arg1)->SetFitHeight(arg2);
46620     } CALL_CATCH_EXCEPTION();
46621   }
46622
46623 }
46624
46625
46626 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
46627   unsigned int jresult ;
46628   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46629   unsigned int arg2 ;
46630   bool result;
46631
46632   arg1 = (Dali::Toolkit::TableView *)jarg1;
46633   arg2 = (unsigned int)jarg2;
46634   {
46635     try {
46636       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
46637     } CALL_CATCH_EXCEPTION(0);
46638   }
46639
46640   jresult = result;
46641   return jresult;
46642 }
46643
46644
46645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
46646   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46647   unsigned int arg2 ;
46648
46649   arg1 = (Dali::Toolkit::TableView *)jarg1;
46650   arg2 = (unsigned int)jarg2;
46651   {
46652     try {
46653       (arg1)->SetFitWidth(arg2);
46654     } CALL_CATCH_EXCEPTION();
46655   }
46656
46657 }
46658
46659
46660 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
46661   unsigned int jresult ;
46662   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46663   unsigned int arg2 ;
46664   bool result;
46665
46666   arg1 = (Dali::Toolkit::TableView *)jarg1;
46667   arg2 = (unsigned int)jarg2;
46668   {
46669     try {
46670       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
46671     } CALL_CATCH_EXCEPTION(0);
46672   }
46673
46674   jresult = result;
46675   return jresult;
46676 }
46677
46678
46679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
46680   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46681   unsigned int arg2 ;
46682   float arg3 ;
46683
46684   arg1 = (Dali::Toolkit::TableView *)jarg1;
46685   arg2 = (unsigned int)jarg2;
46686   arg3 = (float)jarg3;
46687   {
46688     try {
46689       (arg1)->SetFixedHeight(arg2,arg3);
46690     } CALL_CATCH_EXCEPTION();
46691   }
46692
46693 }
46694
46695
46696 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
46697   float jresult ;
46698   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46699   unsigned int arg2 ;
46700   float result;
46701
46702   arg1 = (Dali::Toolkit::TableView *)jarg1;
46703   arg2 = (unsigned int)jarg2;
46704   {
46705     try {
46706       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
46707     } CALL_CATCH_EXCEPTION(0);
46708   }
46709
46710   jresult = result;
46711   return jresult;
46712 }
46713
46714
46715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
46716   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46717   unsigned int arg2 ;
46718   float arg3 ;
46719
46720   arg1 = (Dali::Toolkit::TableView *)jarg1;
46721   arg2 = (unsigned int)jarg2;
46722   arg3 = (float)jarg3;
46723   {
46724     try {
46725       (arg1)->SetRelativeHeight(arg2,arg3);
46726     } CALL_CATCH_EXCEPTION();
46727   }
46728
46729 }
46730
46731
46732 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
46733   float jresult ;
46734   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46735   unsigned int arg2 ;
46736   float result;
46737
46738   arg1 = (Dali::Toolkit::TableView *)jarg1;
46739   arg2 = (unsigned int)jarg2;
46740   {
46741     try {
46742       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
46743     } CALL_CATCH_EXCEPTION(0);
46744   }
46745
46746   jresult = result;
46747   return jresult;
46748 }
46749
46750
46751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
46752   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46753   unsigned int arg2 ;
46754   float arg3 ;
46755
46756   arg1 = (Dali::Toolkit::TableView *)jarg1;
46757   arg2 = (unsigned int)jarg2;
46758   arg3 = (float)jarg3;
46759   {
46760     try {
46761       (arg1)->SetFixedWidth(arg2,arg3);
46762     } CALL_CATCH_EXCEPTION();
46763   }
46764
46765 }
46766
46767
46768 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
46769   float jresult ;
46770   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46771   unsigned int arg2 ;
46772   float result;
46773
46774   arg1 = (Dali::Toolkit::TableView *)jarg1;
46775   arg2 = (unsigned int)jarg2;
46776   {
46777     try {
46778       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
46779     } CALL_CATCH_EXCEPTION(0);
46780   }
46781
46782   jresult = result;
46783   return jresult;
46784 }
46785
46786
46787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
46788   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46789   unsigned int arg2 ;
46790   float arg3 ;
46791
46792   arg1 = (Dali::Toolkit::TableView *)jarg1;
46793   arg2 = (unsigned int)jarg2;
46794   arg3 = (float)jarg3;
46795   {
46796     try {
46797       (arg1)->SetRelativeWidth(arg2,arg3);
46798     } CALL_CATCH_EXCEPTION();
46799   }
46800
46801 }
46802
46803
46804 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
46805   float jresult ;
46806   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46807   unsigned int arg2 ;
46808   float result;
46809
46810   arg1 = (Dali::Toolkit::TableView *)jarg1;
46811   arg2 = (unsigned int)jarg2;
46812   {
46813     try {
46814       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
46815     } CALL_CATCH_EXCEPTION(0);
46816   }
46817
46818   jresult = result;
46819   return jresult;
46820 }
46821
46822
46823 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
46824   unsigned int jresult ;
46825   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46826   unsigned int result;
46827
46828   arg1 = (Dali::Toolkit::TableView *)jarg1;
46829   {
46830     try {
46831       result = (unsigned int)(arg1)->GetRows();
46832     } CALL_CATCH_EXCEPTION(0);
46833   }
46834
46835   jresult = result;
46836   return jresult;
46837 }
46838
46839
46840 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(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)->GetColumns();
46849     } CALL_CATCH_EXCEPTION(0);
46850   }
46851
46852   jresult = result;
46853   return jresult;
46854 }
46855
46856
46857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
46858   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
46859   Dali::Toolkit::TableView::CellPosition arg2 ;
46860   Dali::HorizontalAlignment::Type arg3 ;
46861   Dali::VerticalAlignment::Type arg4 ;
46862   Dali::Toolkit::TableView::CellPosition *argp2 ;
46863
46864   arg1 = (Dali::Toolkit::TableView *)jarg1;
46865   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
46866   if (!argp2) {
46867     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
46868     return ;
46869   }
46870   arg2 = *argp2;
46871   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
46872   arg4 = (Dali::VerticalAlignment::Type)jarg4;
46873   {
46874     try {
46875       (arg1)->SetCellAlignment(arg2,arg3,arg4);
46876     } CALL_CATCH_EXCEPTION();
46877   }
46878
46879 }
46880
46881
46882 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
46883   unsigned int jresult ;
46884   unsigned int result;
46885
46886   result = (unsigned int)(unsigned int)Dali::Toolkit::DevelText::DEFAULT_RENDERING_BACKEND;
46887   jresult = result;
46888   return jresult;
46889 }
46890
46891
46892 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
46893   int jresult ;
46894   int result;
46895
46896   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
46897   jresult = (int)result;
46898   return jresult;
46899 }
46900
46901
46902 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
46903   int jresult ;
46904   int result;
46905
46906   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
46907   jresult = (int)result;
46908   return jresult;
46909 }
46910
46911
46912 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
46913   int jresult ;
46914   int result;
46915
46916   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
46917   jresult = (int)result;
46918   return jresult;
46919 }
46920
46921
46922 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
46923   int jresult ;
46924   int result;
46925
46926   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
46927   jresult = (int)result;
46928   return jresult;
46929 }
46930
46931
46932 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
46933   int jresult ;
46934   int result;
46935
46936   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
46937   jresult = (int)result;
46938   return jresult;
46939 }
46940
46941
46942 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
46943   int jresult ;
46944   int result;
46945
46946   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
46947   jresult = (int)result;
46948   return jresult;
46949 }
46950
46951
46952 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
46953   int jresult ;
46954   int result;
46955
46956   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
46957   jresult = (int)result;
46958   return jresult;
46959 }
46960
46961
46962 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
46963   int jresult ;
46964   int result;
46965
46966   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
46967   jresult = (int)result;
46968   return jresult;
46969 }
46970
46971
46972 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
46973   int jresult ;
46974   int result;
46975
46976   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
46977   jresult = (int)result;
46978   return jresult;
46979 }
46980
46981
46982 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
46983   int jresult ;
46984   int result;
46985
46986   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
46987   jresult = (int)result;
46988   return jresult;
46989 }
46990
46991
46992 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
46993   int jresult ;
46994   int result;
46995
46996   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
46997   jresult = (int)result;
46998   return jresult;
46999 }
47000
47001
47002 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
47003   int jresult ;
47004   int result;
47005
47006   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
47007   jresult = (int)result;
47008   return jresult;
47009 }
47010
47011
47012 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
47013   int jresult ;
47014   int result;
47015
47016   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
47017   jresult = (int)result;
47018   return jresult;
47019 }
47020
47021
47022 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
47023   int jresult ;
47024   int result;
47025
47026   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
47027   jresult = (int)result;
47028   return jresult;
47029 }
47030
47031
47032 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
47033   int jresult ;
47034   int result;
47035
47036   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
47037   jresult = (int)result;
47038   return jresult;
47039 }
47040
47041
47042 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
47043   int jresult ;
47044   int result;
47045
47046   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
47047   jresult = (int)result;
47048   return jresult;
47049 }
47050
47051
47052 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
47053   int jresult ;
47054   int result;
47055
47056   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
47057   jresult = (int)result;
47058   return jresult;
47059 }
47060
47061
47062 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
47063   int jresult ;
47064   int result;
47065
47066   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
47067   jresult = (int)result;
47068   return jresult;
47069 }
47070
47071
47072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
47073   void * jresult ;
47074   Dali::Toolkit::TextLabel::Property *result = 0 ;
47075
47076   {
47077     try {
47078       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
47079     } CALL_CATCH_EXCEPTION(0);
47080   }
47081
47082   jresult = (void *)result;
47083   return jresult;
47084 }
47085
47086
47087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
47088   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
47089
47090   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
47091   {
47092     try {
47093       delete arg1;
47094     } CALL_CATCH_EXCEPTION();
47095   }
47096
47097 }
47098
47099
47100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
47101   void * jresult ;
47102   Dali::Toolkit::TextLabel result;
47103
47104   {
47105     try {
47106       result = Dali::Toolkit::TextLabel::New();
47107     } CALL_CATCH_EXCEPTION(0);
47108   }
47109
47110   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
47111   return jresult;
47112 }
47113
47114
47115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
47116   void * jresult ;
47117   std::string *arg1 = 0 ;
47118   Dali::Toolkit::TextLabel result;
47119
47120   if (!jarg1) {
47121     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
47122     return 0;
47123   }
47124   std::string arg1_str(jarg1);
47125   arg1 = &arg1_str;
47126   {
47127     try {
47128       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
47129     } CALL_CATCH_EXCEPTION(0);
47130   }
47131
47132   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
47133
47134   //argout typemap for const std::string&
47135
47136   return jresult;
47137 }
47138
47139
47140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
47141   void * jresult ;
47142   Dali::Toolkit::TextLabel *result = 0 ;
47143
47144   {
47145     try {
47146       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
47147     } CALL_CATCH_EXCEPTION(0);
47148   }
47149
47150   jresult = (void *)result;
47151   return jresult;
47152 }
47153
47154
47155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
47156   void * jresult ;
47157   Dali::Toolkit::TextLabel *arg1 = 0 ;
47158   Dali::Toolkit::TextLabel *result = 0 ;
47159
47160   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
47161   if (!arg1) {
47162     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
47163     return 0;
47164   }
47165   {
47166     try {
47167       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
47168     } CALL_CATCH_EXCEPTION(0);
47169   }
47170
47171   jresult = (void *)result;
47172   return jresult;
47173 }
47174
47175
47176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
47177   void * jresult ;
47178   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
47179   Dali::Toolkit::TextLabel *arg2 = 0 ;
47180   Dali::Toolkit::TextLabel *result = 0 ;
47181
47182   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
47183   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
47184   if (!arg2) {
47185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
47186     return 0;
47187   }
47188   {
47189     try {
47190       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
47191     } CALL_CATCH_EXCEPTION(0);
47192   }
47193
47194   jresult = (void *)result;
47195   return jresult;
47196 }
47197
47198
47199 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
47200   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
47201
47202   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
47203   {
47204     try {
47205       delete arg1;
47206     } CALL_CATCH_EXCEPTION();
47207   }
47208
47209 }
47210
47211
47212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
47213   void * jresult ;
47214   Dali::BaseHandle arg1 ;
47215   Dali::BaseHandle *argp1 ;
47216   Dali::Toolkit::TextLabel result;
47217
47218   argp1 = (Dali::BaseHandle *)jarg1;
47219   if (!argp1) {
47220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
47221     return 0;
47222   }
47223   arg1 = *argp1;
47224   {
47225     try {
47226       result = Dali::Toolkit::TextLabel::DownCast(arg1);
47227     } CALL_CATCH_EXCEPTION(0);
47228   }
47229
47230   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
47231   return jresult;
47232 }
47233
47234
47235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
47236   void * jresult ;
47237   Dali::Toolkit::AccessibilityManager *result = 0 ;
47238
47239   {
47240     try {
47241       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
47242     } CALL_CATCH_EXCEPTION(0);
47243   }
47244
47245   jresult = (void *)result;
47246   return jresult;
47247 }
47248
47249
47250 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
47251   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47252
47253   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47254   {
47255     try {
47256       delete arg1;
47257     } CALL_CATCH_EXCEPTION();
47258   }
47259
47260 }
47261
47262
47263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
47264   void * jresult ;
47265   Dali::Toolkit::AccessibilityManager result;
47266
47267   {
47268     try {
47269       result = Dali::Toolkit::AccessibilityManager::Get();
47270     } CALL_CATCH_EXCEPTION(0);
47271   }
47272
47273   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
47274   return jresult;
47275 }
47276
47277
47278 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
47279   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47280   Dali::Actor arg2 ;
47281   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
47282   std::string *arg4 = 0 ;
47283   Dali::Actor *argp2 ;
47284
47285   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47286   argp2 = (Dali::Actor *)jarg2;
47287   if (!argp2) {
47288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
47289     return ;
47290   }
47291   arg2 = *argp2;
47292   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
47293   if (!jarg4) {
47294     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
47295     return ;
47296   }
47297   std::string arg4_str(jarg4);
47298   arg4 = &arg4_str;
47299   {
47300     try {
47301       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
47302     } CALL_CATCH_EXCEPTION();
47303   }
47304
47305
47306   //argout typemap for const std::string&
47307
47308 }
47309
47310
47311 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
47312   char * jresult ;
47313   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47314   Dali::Actor arg2 ;
47315   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
47316   Dali::Actor *argp2 ;
47317   std::string result;
47318
47319   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47320   argp2 = (Dali::Actor *)jarg2;
47321   if (!argp2) {
47322     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
47323     return 0;
47324   }
47325   arg2 = *argp2;
47326   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
47327   {
47328     try {
47329       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
47330     } CALL_CATCH_EXCEPTION(0);
47331   }
47332
47333   jresult = SWIG_csharp_string_callback((&result)->c_str());
47334   return jresult;
47335 }
47336
47337
47338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
47339   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47340   Dali::Actor arg2 ;
47341   unsigned int arg3 ;
47342   Dali::Actor *argp2 ;
47343
47344   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47345   argp2 = (Dali::Actor *)jarg2;
47346   if (!argp2) {
47347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
47348     return ;
47349   }
47350   arg2 = *argp2;
47351   arg3 = (unsigned int)jarg3;
47352   {
47353     try {
47354       (arg1)->SetFocusOrder(arg2,arg3);
47355     } CALL_CATCH_EXCEPTION();
47356   }
47357
47358 }
47359
47360
47361 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
47362   unsigned int jresult ;
47363   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47364   Dali::Actor arg2 ;
47365   Dali::Actor *argp2 ;
47366   unsigned int result;
47367
47368   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47369   argp2 = (Dali::Actor *)jarg2;
47370   if (!argp2) {
47371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
47372     return 0;
47373   }
47374   arg2 = *argp2;
47375   {
47376     try {
47377       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
47378     } CALL_CATCH_EXCEPTION(0);
47379   }
47380
47381   jresult = result;
47382   return jresult;
47383 }
47384
47385
47386 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
47387   unsigned int jresult ;
47388   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47389   unsigned int result;
47390
47391   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47392   {
47393     try {
47394       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
47395     } CALL_CATCH_EXCEPTION(0);
47396   }
47397
47398   jresult = result;
47399   return jresult;
47400 }
47401
47402
47403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
47404   void * jresult ;
47405   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47406   unsigned int arg2 ;
47407   Dali::Actor result;
47408
47409   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47410   arg2 = (unsigned int)jarg2;
47411   {
47412     try {
47413       result = (arg1)->GetActorByFocusOrder(arg2);
47414     } CALL_CATCH_EXCEPTION(0);
47415   }
47416
47417   jresult = new Dali::Actor((const Dali::Actor &)result);
47418   return jresult;
47419 }
47420
47421
47422 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
47423   unsigned int jresult ;
47424   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47425   Dali::Actor arg2 ;
47426   Dali::Actor *argp2 ;
47427   bool result;
47428
47429   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47430   argp2 = (Dali::Actor *)jarg2;
47431   if (!argp2) {
47432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
47433     return 0;
47434   }
47435   arg2 = *argp2;
47436   {
47437     try {
47438       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
47439     } CALL_CATCH_EXCEPTION(0);
47440   }
47441
47442   jresult = result;
47443   return jresult;
47444 }
47445
47446
47447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
47448   void * jresult ;
47449   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47450   Dali::Actor result;
47451
47452   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47453   {
47454     try {
47455       result = (arg1)->GetCurrentFocusActor();
47456     } CALL_CATCH_EXCEPTION(0);
47457   }
47458
47459   jresult = new Dali::Actor((const Dali::Actor &)result);
47460   return jresult;
47461 }
47462
47463
47464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(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)->GetCurrentFocusGroup();
47473     } CALL_CATCH_EXCEPTION(0);
47474   }
47475
47476   jresult = new Dali::Actor((const Dali::Actor &)result);
47477   return jresult;
47478 }
47479
47480
47481 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
47482   unsigned int jresult ;
47483   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47484   unsigned int result;
47485
47486   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47487   {
47488     try {
47489       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
47490     } CALL_CATCH_EXCEPTION(0);
47491   }
47492
47493   jresult = result;
47494   return jresult;
47495 }
47496
47497
47498 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
47499   unsigned int jresult ;
47500   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47501   bool result;
47502
47503   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47504   {
47505     try {
47506       result = (bool)(arg1)->MoveFocusForward();
47507     } CALL_CATCH_EXCEPTION(0);
47508   }
47509
47510   jresult = result;
47511   return jresult;
47512 }
47513
47514
47515 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(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)->MoveFocusBackward();
47524     } CALL_CATCH_EXCEPTION(0);
47525   }
47526
47527   jresult = result;
47528   return jresult;
47529 }
47530
47531
47532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
47533   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47534
47535   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47536   {
47537     try {
47538       (arg1)->ClearFocus();
47539     } CALL_CATCH_EXCEPTION();
47540   }
47541
47542 }
47543
47544
47545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
47546   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47547
47548   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47549   {
47550     try {
47551       (arg1)->Reset();
47552     } CALL_CATCH_EXCEPTION();
47553   }
47554
47555 }
47556
47557
47558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
47559   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47560   Dali::Actor arg2 ;
47561   bool arg3 ;
47562   Dali::Actor *argp2 ;
47563
47564   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47565   argp2 = (Dali::Actor *)jarg2;
47566   if (!argp2) {
47567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
47568     return ;
47569   }
47570   arg2 = *argp2;
47571   arg3 = jarg3 ? true : false;
47572   {
47573     try {
47574       (arg1)->SetFocusGroup(arg2,arg3);
47575     } CALL_CATCH_EXCEPTION();
47576   }
47577
47578 }
47579
47580
47581 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
47582   unsigned int jresult ;
47583   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47584   Dali::Actor arg2 ;
47585   Dali::Actor *argp2 ;
47586   bool result;
47587
47588   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47589   argp2 = (Dali::Actor *)jarg2;
47590   if (!argp2) {
47591     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
47592     return 0;
47593   }
47594   arg2 = *argp2;
47595   {
47596     try {
47597       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
47598     } CALL_CATCH_EXCEPTION(0);
47599   }
47600
47601   jresult = result;
47602   return jresult;
47603 }
47604
47605
47606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
47607   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47608   bool arg2 ;
47609
47610   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47611   arg2 = jarg2 ? true : false;
47612   {
47613     try {
47614       (arg1)->SetGroupMode(arg2);
47615     } CALL_CATCH_EXCEPTION();
47616   }
47617
47618 }
47619
47620
47621 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
47622   unsigned int jresult ;
47623   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47624   bool result;
47625
47626   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47627   {
47628     try {
47629       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
47630     } CALL_CATCH_EXCEPTION(0);
47631   }
47632
47633   jresult = result;
47634   return jresult;
47635 }
47636
47637
47638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
47639   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47640   bool arg2 ;
47641
47642   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47643   arg2 = jarg2 ? true : false;
47644   {
47645     try {
47646       (arg1)->SetWrapMode(arg2);
47647     } CALL_CATCH_EXCEPTION();
47648   }
47649
47650 }
47651
47652
47653 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
47654   unsigned int jresult ;
47655   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47656   bool result;
47657
47658   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47659   {
47660     try {
47661       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
47662     } CALL_CATCH_EXCEPTION(0);
47663   }
47664
47665   jresult = result;
47666   return jresult;
47667 }
47668
47669
47670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
47671   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47672   Dali::Actor arg2 ;
47673   Dali::Actor *argp2 ;
47674
47675   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47676   argp2 = (Dali::Actor *)jarg2;
47677   if (!argp2) {
47678     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
47679     return ;
47680   }
47681   arg2 = *argp2;
47682   {
47683     try {
47684       (arg1)->SetFocusIndicatorActor(arg2);
47685     } CALL_CATCH_EXCEPTION();
47686   }
47687
47688 }
47689
47690
47691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
47692   void * jresult ;
47693   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47694   Dali::Actor result;
47695
47696   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47697   {
47698     try {
47699       result = (arg1)->GetFocusIndicatorActor();
47700     } CALL_CATCH_EXCEPTION(0);
47701   }
47702
47703   jresult = new Dali::Actor((const Dali::Actor &)result);
47704   return jresult;
47705 }
47706
47707
47708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
47709   void * jresult ;
47710   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47711   Dali::Actor arg2 ;
47712   Dali::Actor *argp2 ;
47713   Dali::Actor result;
47714
47715   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47716   argp2 = (Dali::Actor *)jarg2;
47717   if (!argp2) {
47718     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
47719     return 0;
47720   }
47721   arg2 = *argp2;
47722   {
47723     try {
47724       result = (arg1)->GetFocusGroup(arg2);
47725     } CALL_CATCH_EXCEPTION(0);
47726   }
47727
47728   jresult = new Dali::Actor((const Dali::Actor &)result);
47729   return jresult;
47730 }
47731
47732
47733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
47734   void * jresult ;
47735   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47736   Dali::Vector2 result;
47737
47738   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47739   {
47740     try {
47741       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
47742     } CALL_CATCH_EXCEPTION(0);
47743   }
47744
47745   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
47746   return jresult;
47747 }
47748
47749
47750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
47751   void * jresult ;
47752   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47753   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
47754
47755   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47756   {
47757     try {
47758       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
47759     } CALL_CATCH_EXCEPTION(0);
47760   }
47761
47762   jresult = (void *)result;
47763   return jresult;
47764 }
47765
47766
47767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
47768   void * jresult ;
47769   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47770   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
47771
47772   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47773   {
47774     try {
47775       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
47776     } CALL_CATCH_EXCEPTION(0);
47777   }
47778
47779   jresult = (void *)result;
47780   return jresult;
47781 }
47782
47783
47784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
47785   void * jresult ;
47786   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47787   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
47788
47789   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47790   {
47791     try {
47792       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
47793     } CALL_CATCH_EXCEPTION(0);
47794   }
47795
47796   jresult = (void *)result;
47797   return jresult;
47798 }
47799
47800
47801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
47802   void * jresult ;
47803   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
47804   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
47805
47806   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
47807   {
47808     try {
47809       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
47810     } CALL_CATCH_EXCEPTION(0);
47811   }
47812
47813   jresult = (void *)result;
47814   return jresult;
47815 }
47816
47817
47818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(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)->ActionNextSignal();
47827     } CALL_CATCH_EXCEPTION(0);
47828   }
47829
47830   jresult = (void *)result;
47831   return jresult;
47832 }
47833
47834
47835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(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)->ActionPreviousSignal();
47844     } CALL_CATCH_EXCEPTION(0);
47845   }
47846
47847   jresult = (void *)result;
47848   return jresult;
47849 }
47850
47851
47852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(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)->ActionActivateSignal();
47861     } CALL_CATCH_EXCEPTION(0);
47862   }
47863
47864   jresult = (void *)result;
47865   return jresult;
47866 }
47867
47868
47869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(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)->ActionReadSignal();
47878     } CALL_CATCH_EXCEPTION(0);
47879   }
47880
47881   jresult = (void *)result;
47882   return jresult;
47883 }
47884
47885
47886 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(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)->ActionOverSignal();
47895     } CALL_CATCH_EXCEPTION(0);
47896   }
47897
47898   jresult = (void *)result;
47899   return jresult;
47900 }
47901
47902
47903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(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)->ActionReadNextSignal();
47912     } CALL_CATCH_EXCEPTION(0);
47913   }
47914
47915   jresult = (void *)result;
47916   return jresult;
47917 }
47918
47919
47920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(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)->ActionReadPreviousSignal();
47929     } CALL_CATCH_EXCEPTION(0);
47930   }
47931
47932   jresult = (void *)result;
47933   return jresult;
47934 }
47935
47936
47937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(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)->ActionUpSignal();
47946     } CALL_CATCH_EXCEPTION(0);
47947   }
47948
47949   jresult = (void *)result;
47950   return jresult;
47951 }
47952
47953
47954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(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)->ActionDownSignal();
47963     } CALL_CATCH_EXCEPTION(0);
47964   }
47965
47966   jresult = (void *)result;
47967   return jresult;
47968 }
47969
47970
47971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(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)->ActionClearFocusSignal();
47980     } CALL_CATCH_EXCEPTION(0);
47981   }
47982
47983   jresult = (void *)result;
47984   return jresult;
47985 }
47986
47987
47988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(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)->ActionBackSignal();
47997     } CALL_CATCH_EXCEPTION(0);
47998   }
47999
48000   jresult = (void *)result;
48001   return jresult;
48002 }
48003
48004
48005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(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)->ActionScrollUpSignal();
48014     } CALL_CATCH_EXCEPTION(0);
48015   }
48016
48017   jresult = (void *)result;
48018   return jresult;
48019 }
48020
48021
48022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(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)->ActionScrollDownSignal();
48031     } CALL_CATCH_EXCEPTION(0);
48032   }
48033
48034   jresult = (void *)result;
48035   return jresult;
48036 }
48037
48038
48039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(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)->ActionPageLeftSignal();
48048     } CALL_CATCH_EXCEPTION(0);
48049   }
48050
48051   jresult = (void *)result;
48052   return jresult;
48053 }
48054
48055
48056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(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)->ActionPageRightSignal();
48065     } CALL_CATCH_EXCEPTION(0);
48066   }
48067
48068   jresult = (void *)result;
48069   return jresult;
48070 }
48071
48072
48073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(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)->ActionPageUpSignal();
48082     } CALL_CATCH_EXCEPTION(0);
48083   }
48084
48085   jresult = (void *)result;
48086   return jresult;
48087 }
48088
48089
48090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(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)->ActionPageDownSignal();
48099     } CALL_CATCH_EXCEPTION(0);
48100   }
48101
48102   jresult = (void *)result;
48103   return jresult;
48104 }
48105
48106
48107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(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)->ActionMoveToFirstSignal();
48116     } CALL_CATCH_EXCEPTION(0);
48117   }
48118
48119   jresult = (void *)result;
48120   return jresult;
48121 }
48122
48123
48124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(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)->ActionMoveToLastSignal();
48133     } CALL_CATCH_EXCEPTION(0);
48134   }
48135
48136   jresult = (void *)result;
48137   return jresult;
48138 }
48139
48140
48141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(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)->ActionReadFromTopSignal();
48150     } CALL_CATCH_EXCEPTION(0);
48151   }
48152
48153   jresult = (void *)result;
48154   return jresult;
48155 }
48156
48157
48158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(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)->ActionReadFromNextSignal();
48167     } CALL_CATCH_EXCEPTION(0);
48168   }
48169
48170   jresult = (void *)result;
48171   return jresult;
48172 }
48173
48174
48175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(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)->ActionZoomSignal();
48184     } CALL_CATCH_EXCEPTION(0);
48185   }
48186
48187   jresult = (void *)result;
48188   return jresult;
48189 }
48190
48191
48192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(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)->ActionReadPauseResumeSignal();
48201     } CALL_CATCH_EXCEPTION(0);
48202   }
48203
48204   jresult = (void *)result;
48205   return jresult;
48206 }
48207
48208
48209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(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)->ActionStartStopSignal();
48218     } CALL_CATCH_EXCEPTION(0);
48219   }
48220
48221   jresult = (void *)result;
48222   return jresult;
48223 }
48224
48225
48226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
48227   void * jresult ;
48228   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
48229   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
48230
48231   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
48232   {
48233     try {
48234       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
48235     } CALL_CATCH_EXCEPTION(0);
48236   }
48237
48238   jresult = (void *)result;
48239   return jresult;
48240 }
48241
48242
48243 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
48244   void * jresult ;
48245   Dali::Toolkit::StyleManager *result = 0 ;
48246
48247   {
48248     try {
48249       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
48250     } CALL_CATCH_EXCEPTION(0);
48251   }
48252
48253   jresult = (void *)result;
48254   return jresult;
48255 }
48256
48257
48258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
48259   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
48260
48261   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
48262   {
48263     try {
48264       delete arg1;
48265     } CALL_CATCH_EXCEPTION();
48266   }
48267
48268 }
48269
48270
48271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
48272   void * jresult ;
48273   Dali::Toolkit::StyleManager result;
48274
48275   {
48276     try {
48277       result = Dali::Toolkit::StyleManager::Get();
48278     } CALL_CATCH_EXCEPTION(0);
48279   }
48280
48281   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
48282   return jresult;
48283 }
48284
48285
48286 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
48287   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
48288   std::string *arg2 = 0 ;
48289
48290   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
48291   if (!jarg2) {
48292     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
48293     return ;
48294   }
48295   std::string arg2_str(jarg2);
48296   arg2 = &arg2_str;
48297   {
48298     try {
48299       (arg1)->ApplyTheme((std::string const &)*arg2);
48300     } CALL_CATCH_EXCEPTION();
48301   }
48302
48303
48304   //argout typemap for const std::string&
48305
48306 }
48307
48308
48309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
48310   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
48311
48312   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
48313   {
48314     try {
48315       (arg1)->ApplyDefaultTheme();
48316     } CALL_CATCH_EXCEPTION();
48317   }
48318
48319 }
48320
48321
48322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
48323   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
48324   std::string *arg2 = 0 ;
48325   Dali::Property::Value *arg3 = 0 ;
48326
48327   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
48328   if (!jarg2) {
48329     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
48330     return ;
48331   }
48332   std::string arg2_str(jarg2);
48333   arg2 = &arg2_str;
48334   arg3 = (Dali::Property::Value *)jarg3;
48335   if (!arg3) {
48336     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
48337     return ;
48338   }
48339   {
48340     try {
48341       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
48342     } CALL_CATCH_EXCEPTION();
48343   }
48344
48345
48346   //argout typemap for const std::string&
48347
48348 }
48349
48350
48351 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
48352   unsigned int jresult ;
48353   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
48354   std::string *arg2 = 0 ;
48355   Dali::Property::Value *arg3 = 0 ;
48356   bool result;
48357
48358   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
48359   if (!jarg2) {
48360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
48361     return 0;
48362   }
48363   std::string arg2_str(jarg2);
48364   arg2 = &arg2_str;
48365   arg3 = (Dali::Property::Value *)jarg3;
48366   if (!arg3) {
48367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
48368     return 0;
48369   }
48370   {
48371     try {
48372       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
48373     } CALL_CATCH_EXCEPTION(0);
48374   }
48375
48376   jresult = result;
48377
48378   //argout typemap for const std::string&
48379
48380   return jresult;
48381 }
48382
48383
48384 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
48385   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
48386   Dali::Toolkit::Control arg2 ;
48387   std::string *arg3 = 0 ;
48388   std::string *arg4 = 0 ;
48389   Dali::Toolkit::Control *argp2 ;
48390
48391   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
48392   argp2 = (Dali::Toolkit::Control *)jarg2;
48393   if (!argp2) {
48394     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
48395     return ;
48396   }
48397   arg2 = *argp2;
48398   if (!jarg3) {
48399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
48400     return ;
48401   }
48402   std::string arg3_str(jarg3);
48403   arg3 = &arg3_str;
48404   if (!jarg4) {
48405     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
48406     return ;
48407   }
48408   std::string arg4_str(jarg4);
48409   arg4 = &arg4_str;
48410   {
48411     try {
48412       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
48413     } CALL_CATCH_EXCEPTION();
48414   }
48415
48416
48417   //argout typemap for const std::string&
48418
48419
48420   //argout typemap for const std::string&
48421
48422 }
48423
48424
48425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
48426   void * jresult ;
48427   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
48428   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
48429
48430   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
48431   {
48432     try {
48433       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
48434     } CALL_CATCH_EXCEPTION(0);
48435   }
48436
48437   jresult = (void *)result;
48438   return jresult;
48439 }
48440
48441
48442 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
48443   int jresult ;
48444   int result;
48445
48446   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
48447   jresult = (int)result;
48448   return jresult;
48449 }
48450
48451
48452 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
48453   int jresult ;
48454   int result;
48455
48456   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
48457   jresult = (int)result;
48458   return jresult;
48459 }
48460
48461
48462 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
48463   int jresult ;
48464   int result;
48465
48466   result = (int)Dali::Toolkit::Slider::Property::VALUE;
48467   jresult = (int)result;
48468   return jresult;
48469 }
48470
48471
48472 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
48473   int jresult ;
48474   int result;
48475
48476   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
48477   jresult = (int)result;
48478   return jresult;
48479 }
48480
48481
48482 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
48483   int jresult ;
48484   int result;
48485
48486   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
48487   jresult = (int)result;
48488   return jresult;
48489 }
48490
48491
48492 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
48493   int jresult ;
48494   int result;
48495
48496   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
48497   jresult = (int)result;
48498   return jresult;
48499 }
48500
48501
48502 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
48503   int jresult ;
48504   int result;
48505
48506   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
48507   jresult = (int)result;
48508   return jresult;
48509 }
48510
48511
48512 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
48513   int jresult ;
48514   int result;
48515
48516   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
48517   jresult = (int)result;
48518   return jresult;
48519 }
48520
48521
48522 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
48523   int jresult ;
48524   int result;
48525
48526   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
48527   jresult = (int)result;
48528   return jresult;
48529 }
48530
48531
48532 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
48533   int jresult ;
48534   int result;
48535
48536   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
48537   jresult = (int)result;
48538   return jresult;
48539 }
48540
48541
48542 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
48543   int jresult ;
48544   int result;
48545
48546   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
48547   jresult = (int)result;
48548   return jresult;
48549 }
48550
48551
48552 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
48553   int jresult ;
48554   int result;
48555
48556   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
48557   jresult = (int)result;
48558   return jresult;
48559 }
48560
48561
48562 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
48563   int jresult ;
48564   int result;
48565
48566   result = (int)Dali::Toolkit::Slider::Property::MARKS;
48567   jresult = (int)result;
48568   return jresult;
48569 }
48570
48571
48572 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
48573   int jresult ;
48574   int result;
48575
48576   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
48577   jresult = (int)result;
48578   return jresult;
48579 }
48580
48581
48582 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
48583   int jresult ;
48584   int result;
48585
48586   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
48587   jresult = (int)result;
48588   return jresult;
48589 }
48590
48591
48592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
48593   void * jresult ;
48594   Dali::Toolkit::Slider::Property *result = 0 ;
48595
48596   {
48597     try {
48598       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
48599     } CALL_CATCH_EXCEPTION(0);
48600   }
48601
48602   jresult = (void *)result;
48603   return jresult;
48604 }
48605
48606
48607 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
48608   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
48609
48610   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
48611   {
48612     try {
48613       delete arg1;
48614     } CALL_CATCH_EXCEPTION();
48615   }
48616
48617 }
48618
48619
48620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
48621   void * jresult ;
48622   Dali::Toolkit::Slider result;
48623
48624   {
48625     try {
48626       result = Dali::Toolkit::Slider::New();
48627     } CALL_CATCH_EXCEPTION(0);
48628   }
48629
48630   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
48631   return jresult;
48632 }
48633
48634
48635 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
48636   void * jresult ;
48637   Dali::Toolkit::Slider *result = 0 ;
48638
48639   {
48640     try {
48641       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
48642     } CALL_CATCH_EXCEPTION(0);
48643   }
48644
48645   jresult = (void *)result;
48646   return jresult;
48647 }
48648
48649
48650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
48651   void * jresult ;
48652   Dali::Toolkit::Slider *arg1 = 0 ;
48653   Dali::Toolkit::Slider *result = 0 ;
48654
48655   arg1 = (Dali::Toolkit::Slider *)jarg1;
48656   if (!arg1) {
48657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
48658     return 0;
48659   }
48660   {
48661     try {
48662       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
48663     } CALL_CATCH_EXCEPTION(0);
48664   }
48665
48666   jresult = (void *)result;
48667   return jresult;
48668 }
48669
48670
48671 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
48672   void * jresult ;
48673   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
48674   Dali::Toolkit::Slider *arg2 = 0 ;
48675   Dali::Toolkit::Slider *result = 0 ;
48676
48677   arg1 = (Dali::Toolkit::Slider *)jarg1;
48678   arg2 = (Dali::Toolkit::Slider *)jarg2;
48679   if (!arg2) {
48680     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
48681     return 0;
48682   }
48683   {
48684     try {
48685       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
48686     } CALL_CATCH_EXCEPTION(0);
48687   }
48688
48689   jresult = (void *)result;
48690   return jresult;
48691 }
48692
48693
48694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
48695   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
48696
48697   arg1 = (Dali::Toolkit::Slider *)jarg1;
48698   {
48699     try {
48700       delete arg1;
48701     } CALL_CATCH_EXCEPTION();
48702   }
48703
48704 }
48705
48706
48707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
48708   void * jresult ;
48709   Dali::BaseHandle arg1 ;
48710   Dali::BaseHandle *argp1 ;
48711   Dali::Toolkit::Slider result;
48712
48713   argp1 = (Dali::BaseHandle *)jarg1;
48714   if (!argp1) {
48715     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
48716     return 0;
48717   }
48718   arg1 = *argp1;
48719   {
48720     try {
48721       result = Dali::Toolkit::Slider::DownCast(arg1);
48722     } CALL_CATCH_EXCEPTION(0);
48723   }
48724
48725   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
48726   return jresult;
48727 }
48728
48729
48730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
48731   void * jresult ;
48732   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
48733   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
48734
48735   arg1 = (Dali::Toolkit::Slider *)jarg1;
48736   {
48737     try {
48738       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
48739     } CALL_CATCH_EXCEPTION(0);
48740   }
48741
48742   jresult = (void *)result;
48743   return jresult;
48744 }
48745
48746
48747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(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)->SlidingFinishedSignal();
48756     } CALL_CATCH_EXCEPTION(0);
48757   }
48758
48759   jresult = (void *)result;
48760   return jresult;
48761 }
48762
48763
48764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
48765   void * jresult ;
48766   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
48767   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
48768
48769   arg1 = (Dali::Toolkit::Slider *)jarg1;
48770   {
48771     try {
48772       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
48773     } CALL_CATCH_EXCEPTION(0);
48774   }
48775
48776   jresult = (void *)result;
48777   return jresult;
48778 }
48779
48780
48781 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
48782   int jresult ;
48783   int result;
48784
48785   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
48786   jresult = (int)result;
48787   return jresult;
48788 }
48789
48790
48791 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
48792   int jresult ;
48793   int result;
48794
48795   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
48796   jresult = (int)result;
48797   return jresult;
48798 }
48799
48800
48801 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
48802   int jresult ;
48803   int result;
48804
48805   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
48806   jresult = (int)result;
48807   return jresult;
48808 }
48809
48810
48811 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
48812   int jresult ;
48813   int result;
48814
48815   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
48816   jresult = (int)result;
48817   return jresult;
48818 }
48819
48820
48821 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_UNDERLAY_get() {
48822   int result;
48823
48824   result = (int)Dali::Toolkit::VideoView::Property::UNDERLAY;
48825
48826   return result;
48827 }
48828
48829
48830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
48831   void * jresult ;
48832   Dali::Toolkit::VideoView::Property *result = 0 ;
48833
48834   {
48835     try {
48836       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
48837     } CALL_CATCH_EXCEPTION(0);
48838   }
48839
48840   jresult = (void *)result;
48841   return jresult;
48842 }
48843
48844
48845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
48846   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
48847
48848   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
48849   {
48850     try {
48851       delete arg1;
48852     } CALL_CATCH_EXCEPTION();
48853   }
48854
48855 }
48856
48857
48858 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
48859   void * jresult ;
48860   Dali::Toolkit::VideoView result;
48861
48862   {
48863     try {
48864       result = Dali::Toolkit::VideoView::New();
48865     } CALL_CATCH_EXCEPTION(0);
48866   }
48867
48868   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
48869   return jresult;
48870 }
48871
48872
48873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
48874   void * jresult ;
48875   std::string *arg1 = 0 ;
48876   Dali::Toolkit::VideoView result;
48877
48878   if (!jarg1) {
48879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
48880     return 0;
48881   }
48882   std::string arg1_str(jarg1);
48883   arg1 = &arg1_str;
48884   {
48885     try {
48886       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
48887     } CALL_CATCH_EXCEPTION(0);
48888   }
48889
48890   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
48891
48892   //argout typemap for const std::string&
48893
48894   return jresult;
48895 }
48896
48897
48898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_2(bool swCodec) {
48899   void * jresult ;
48900   Dali::Toolkit::VideoView result;
48901   {
48902     try {
48903       result = Dali::Toolkit::VideoView::New(swCodec);
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_3(char * jarg1, bool swCodec) {
48916   void * jresult ;
48917   std::string *arg1 = 0 ;
48918   Dali::Toolkit::VideoView result;
48919
48920   if (!jarg1) {
48921     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
48922     return 0;
48923   }
48924   std::string arg1_str(jarg1);
48925   arg1 = &arg1_str;
48926   {
48927     try {
48928       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1, swCodec);
48929     } CALL_CATCH_EXCEPTION(0);
48930   }
48931
48932   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
48933
48934   //argout typemap for const std::string&
48935
48936   return jresult;
48937 }
48938
48939
48940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
48941   void * jresult ;
48942   Dali::Toolkit::VideoView *result = 0 ;
48943
48944   {
48945     try {
48946       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
48947     } CALL_CATCH_EXCEPTION(0);
48948   }
48949
48950   jresult = (void *)result;
48951   return jresult;
48952 }
48953
48954
48955 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
48956   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
48957
48958   arg1 = (Dali::Toolkit::VideoView *)jarg1;
48959   {
48960     try {
48961       delete arg1;
48962     } CALL_CATCH_EXCEPTION();
48963   }
48964
48965 }
48966
48967
48968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
48969   void * jresult ;
48970   Dali::Toolkit::VideoView *arg1 = 0 ;
48971   Dali::Toolkit::VideoView *result = 0 ;
48972
48973   arg1 = (Dali::Toolkit::VideoView *)jarg1;
48974   if (!arg1) {
48975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
48976     return 0;
48977   }
48978   {
48979     try {
48980       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
48981     } CALL_CATCH_EXCEPTION(0);
48982   }
48983
48984   jresult = (void *)result;
48985   return jresult;
48986 }
48987
48988
48989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
48990   void * jresult ;
48991   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
48992   Dali::Toolkit::VideoView *arg2 = 0 ;
48993   Dali::Toolkit::VideoView *result = 0 ;
48994
48995   arg1 = (Dali::Toolkit::VideoView *)jarg1;
48996   arg2 = (Dali::Toolkit::VideoView *)jarg2;
48997   if (!arg2) {
48998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
48999     return 0;
49000   }
49001   {
49002     try {
49003       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
49004     } CALL_CATCH_EXCEPTION(0);
49005   }
49006
49007   jresult = (void *)result;
49008   return jresult;
49009 }
49010
49011
49012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
49013   void * jresult ;
49014   Dali::BaseHandle arg1 ;
49015   Dali::BaseHandle *argp1 ;
49016   Dali::Toolkit::VideoView result;
49017
49018   argp1 = (Dali::BaseHandle *)jarg1;
49019   if (!argp1) {
49020     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
49021     return 0;
49022   }
49023   arg1 = *argp1;
49024   {
49025     try {
49026       result = Dali::Toolkit::VideoView::DownCast(arg1);
49027     } CALL_CATCH_EXCEPTION(0);
49028   }
49029
49030   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
49031   return jresult;
49032 }
49033
49034
49035 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
49036   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
49037
49038   arg1 = (Dali::Toolkit::VideoView *)jarg1;
49039   {
49040     try {
49041       (arg1)->Play();
49042     } CALL_CATCH_EXCEPTION();
49043   }
49044
49045 }
49046
49047
49048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
49049   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
49050
49051   arg1 = (Dali::Toolkit::VideoView *)jarg1;
49052   {
49053     try {
49054       (arg1)->Pause();
49055     } CALL_CATCH_EXCEPTION();
49056   }
49057
49058 }
49059
49060
49061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
49062   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
49063
49064   arg1 = (Dali::Toolkit::VideoView *)jarg1;
49065   {
49066     try {
49067       (arg1)->Stop();
49068     } CALL_CATCH_EXCEPTION();
49069   }
49070
49071 }
49072
49073
49074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
49075   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
49076   int arg2 ;
49077
49078   arg1 = (Dali::Toolkit::VideoView *)jarg1;
49079   arg2 = (int)jarg2;
49080   {
49081     try {
49082       (arg1)->Forward(arg2);
49083     } CALL_CATCH_EXCEPTION();
49084   }
49085
49086 }
49087
49088
49089 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
49090   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
49091   int arg2 ;
49092
49093   arg1 = (Dali::Toolkit::VideoView *)jarg1;
49094   arg2 = (int)jarg2;
49095   {
49096     try {
49097       (arg1)->Backward(arg2);
49098     } CALL_CATCH_EXCEPTION();
49099   }
49100
49101 }
49102
49103
49104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
49105   void * jresult ;
49106   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
49107   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
49108
49109   arg1 = (Dali::Toolkit::VideoView *)jarg1;
49110   {
49111     try {
49112       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
49113     } CALL_CATCH_EXCEPTION(0);
49114   }
49115
49116   jresult = (void *)result;
49117   return jresult;
49118 }
49119
49120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_GetNativePlayerHandle( void * jarg1 )
49121 {
49122   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *)jarg1;
49123   if( arg1 == nullptr )
49124   {
49125     DALI_LOG_ERROR("VideoView is nullptr!");
49126     return nullptr;
49127   }
49128   void * ret = nullptr;
49129   {
49130     try{
49131
49132       Dali::Any result = Toolkit::DevelVideoView::GetMediaPlayer( *arg1 );
49133       ret = Dali::AnyCast< void * >( result );
49134
49135     } CALL_CATCH_EXCEPTION(0);
49136   }
49137   return ret;
49138 }
49139
49140
49141 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
49142   int jresult ;
49143   int result;
49144
49145   result = (int)Dali::Toolkit::Popup::Property::TITLE;
49146   jresult = (int)result;
49147   return jresult;
49148 }
49149
49150
49151 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
49152   int jresult ;
49153   int result;
49154
49155   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
49156   jresult = (int)result;
49157   return jresult;
49158 }
49159
49160
49161 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
49162   int jresult ;
49163   int result;
49164
49165   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
49166   jresult = (int)result;
49167   return jresult;
49168 }
49169
49170
49171 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
49172   int jresult ;
49173   int result;
49174
49175   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
49176   jresult = (int)result;
49177   return jresult;
49178 }
49179
49180
49181 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
49182   int jresult ;
49183   int result;
49184
49185   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
49186   jresult = (int)result;
49187   return jresult;
49188 }
49189
49190
49191 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
49192   int jresult ;
49193   int result;
49194
49195   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
49196   jresult = (int)result;
49197   return jresult;
49198 }
49199
49200
49201 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
49202   int jresult ;
49203   int result;
49204
49205   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
49206   jresult = (int)result;
49207   return jresult;
49208 }
49209
49210
49211 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
49212   int jresult ;
49213   int result;
49214
49215   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
49216   jresult = (int)result;
49217   return jresult;
49218 }
49219
49220
49221 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
49222   int jresult ;
49223   int result;
49224
49225   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
49226   jresult = (int)result;
49227   return jresult;
49228 }
49229
49230
49231 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
49232   int jresult ;
49233   int result;
49234
49235   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
49236   jresult = (int)result;
49237   return jresult;
49238 }
49239
49240
49241 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
49242   int jresult ;
49243   int result;
49244
49245   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
49246   jresult = (int)result;
49247   return jresult;
49248 }
49249
49250
49251 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
49252   int jresult ;
49253   int result;
49254
49255   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
49256   jresult = (int)result;
49257   return jresult;
49258 }
49259
49260
49261 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
49262   int jresult ;
49263   int result;
49264
49265   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
49266   jresult = (int)result;
49267   return jresult;
49268 }
49269
49270
49271 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
49272   int jresult ;
49273   int result;
49274
49275   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
49276   jresult = (int)result;
49277   return jresult;
49278 }
49279
49280
49281 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
49282   int jresult ;
49283   int result;
49284
49285   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
49286   jresult = (int)result;
49287   return jresult;
49288 }
49289
49290
49291 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
49292   int jresult ;
49293   int result;
49294
49295   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
49296   jresult = (int)result;
49297   return jresult;
49298 }
49299
49300
49301 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
49302   int jresult ;
49303   int result;
49304
49305   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
49306   jresult = (int)result;
49307   return jresult;
49308 }
49309
49310
49311 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
49312   int jresult ;
49313   int result;
49314
49315   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
49316   jresult = (int)result;
49317   return jresult;
49318 }
49319
49320
49321 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
49322   int jresult ;
49323   int result;
49324
49325   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
49326   jresult = (int)result;
49327   return jresult;
49328 }
49329
49330
49331 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
49332   int jresult ;
49333   int result;
49334
49335   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
49336   jresult = (int)result;
49337   return jresult;
49338 }
49339
49340
49341 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
49342   int jresult ;
49343   int result;
49344
49345   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
49346   jresult = (int)result;
49347   return jresult;
49348 }
49349
49350
49351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
49352   void * jresult ;
49353   Dali::Toolkit::Popup::Property *result = 0 ;
49354
49355   {
49356     try {
49357       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
49358     } CALL_CATCH_EXCEPTION(0);
49359   }
49360
49361   jresult = (void *)result;
49362   return jresult;
49363 }
49364
49365
49366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
49367   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
49368
49369   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
49370   {
49371     try {
49372       delete arg1;
49373     } CALL_CATCH_EXCEPTION();
49374   }
49375
49376 }
49377
49378
49379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
49380   void * jresult ;
49381   Dali::Toolkit::Popup *result = 0 ;
49382
49383   {
49384     try {
49385       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
49386     } CALL_CATCH_EXCEPTION(0);
49387   }
49388
49389   jresult = (void *)result;
49390   return jresult;
49391 }
49392
49393
49394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
49395   void * jresult ;
49396   Dali::Toolkit::Popup result;
49397
49398   {
49399     try {
49400       result = Dali::Toolkit::Popup::New();
49401     } CALL_CATCH_EXCEPTION(0);
49402   }
49403
49404   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
49405   return jresult;
49406 }
49407
49408
49409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
49410   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
49411
49412   arg1 = (Dali::Toolkit::Popup *)jarg1;
49413   {
49414     try {
49415       delete arg1;
49416     } CALL_CATCH_EXCEPTION();
49417   }
49418
49419 }
49420
49421
49422 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
49423   void * jresult ;
49424   Dali::Toolkit::Popup *arg1 = 0 ;
49425   Dali::Toolkit::Popup *result = 0 ;
49426
49427   arg1 = (Dali::Toolkit::Popup *)jarg1;
49428   if (!arg1) {
49429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
49430     return 0;
49431   }
49432   {
49433     try {
49434       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
49435     } CALL_CATCH_EXCEPTION(0);
49436   }
49437
49438   jresult = (void *)result;
49439   return jresult;
49440 }
49441
49442
49443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
49444   void * jresult ;
49445   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
49446   Dali::Toolkit::Popup *arg2 = 0 ;
49447   Dali::Toolkit::Popup *result = 0 ;
49448
49449   arg1 = (Dali::Toolkit::Popup *)jarg1;
49450   arg2 = (Dali::Toolkit::Popup *)jarg2;
49451   if (!arg2) {
49452     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
49453     return 0;
49454   }
49455   {
49456     try {
49457       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
49458     } CALL_CATCH_EXCEPTION(0);
49459   }
49460
49461   jresult = (void *)result;
49462   return jresult;
49463 }
49464
49465
49466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
49467   void * jresult ;
49468   Dali::BaseHandle arg1 ;
49469   Dali::BaseHandle *argp1 ;
49470   Dali::Toolkit::Popup result;
49471
49472   argp1 = (Dali::BaseHandle *)jarg1;
49473   if (!argp1) {
49474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
49475     return 0;
49476   }
49477   arg1 = *argp1;
49478   {
49479     try {
49480       result = Dali::Toolkit::Popup::DownCast(arg1);
49481     } CALL_CATCH_EXCEPTION(0);
49482   }
49483
49484   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
49485   return jresult;
49486 }
49487
49488
49489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
49490   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
49491   Dali::Actor arg2 ;
49492   Dali::Actor *argp2 ;
49493
49494   arg1 = (Dali::Toolkit::Popup *)jarg1;
49495   argp2 = (Dali::Actor *)jarg2;
49496   if (!argp2) {
49497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
49498     return ;
49499   }
49500   arg2 = *argp2;
49501   {
49502     try {
49503       (arg1)->SetTitle(arg2);
49504     } CALL_CATCH_EXCEPTION();
49505   }
49506
49507 }
49508
49509
49510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
49511   void * jresult ;
49512   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
49513   Dali::Actor result;
49514
49515   arg1 = (Dali::Toolkit::Popup *)jarg1;
49516   {
49517     try {
49518       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
49519     } CALL_CATCH_EXCEPTION(0);
49520   }
49521
49522   jresult = new Dali::Actor((const Dali::Actor &)result);
49523   return jresult;
49524 }
49525
49526
49527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
49528   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
49529   Dali::Actor arg2 ;
49530   Dali::Actor *argp2 ;
49531
49532   arg1 = (Dali::Toolkit::Popup *)jarg1;
49533   argp2 = (Dali::Actor *)jarg2;
49534   if (!argp2) {
49535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
49536     return ;
49537   }
49538   arg2 = *argp2;
49539   {
49540     try {
49541       (arg1)->SetContent(arg2);
49542     } CALL_CATCH_EXCEPTION();
49543   }
49544
49545 }
49546
49547
49548 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
49549   void * jresult ;
49550   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
49551   Dali::Actor result;
49552
49553   arg1 = (Dali::Toolkit::Popup *)jarg1;
49554   {
49555     try {
49556       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
49557     } CALL_CATCH_EXCEPTION(0);
49558   }
49559
49560   jresult = new Dali::Actor((const Dali::Actor &)result);
49561   return jresult;
49562 }
49563
49564
49565 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
49566   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
49567   Dali::Actor arg2 ;
49568   Dali::Actor *argp2 ;
49569
49570   arg1 = (Dali::Toolkit::Popup *)jarg1;
49571   argp2 = (Dali::Actor *)jarg2;
49572   if (!argp2) {
49573     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
49574     return ;
49575   }
49576   arg2 = *argp2;
49577   {
49578     try {
49579       (arg1)->SetFooter(arg2);
49580     } CALL_CATCH_EXCEPTION();
49581   }
49582
49583 }
49584
49585
49586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
49587   void * jresult ;
49588   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
49589   Dali::Actor result;
49590
49591   arg1 = (Dali::Toolkit::Popup *)jarg1;
49592   {
49593     try {
49594       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
49595     } CALL_CATCH_EXCEPTION(0);
49596   }
49597
49598   jresult = new Dali::Actor((const Dali::Actor &)result);
49599   return jresult;
49600 }
49601
49602
49603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
49604   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
49605   Dali::Toolkit::Popup::DisplayState arg2 ;
49606
49607   arg1 = (Dali::Toolkit::Popup *)jarg1;
49608   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
49609   {
49610     try {
49611       (arg1)->SetDisplayState(arg2);
49612     } CALL_CATCH_EXCEPTION();
49613   }
49614
49615 }
49616
49617
49618 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
49619   int jresult ;
49620   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
49621   Dali::Toolkit::Popup::DisplayState result;
49622
49623   arg1 = (Dali::Toolkit::Popup *)jarg1;
49624   {
49625     try {
49626       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
49627     } CALL_CATCH_EXCEPTION(0);
49628   }
49629
49630   jresult = (int)result;
49631   return jresult;
49632 }
49633
49634
49635 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
49636   void * jresult ;
49637   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
49638   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
49639
49640   arg1 = (Dali::Toolkit::Popup *)jarg1;
49641   {
49642     try {
49643       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
49644     } CALL_CATCH_EXCEPTION(0);
49645   }
49646
49647   jresult = (void *)result;
49648   return jresult;
49649 }
49650
49651
49652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
49653   void * jresult ;
49654   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
49655   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
49656
49657   arg1 = (Dali::Toolkit::Popup *)jarg1;
49658   {
49659     try {
49660       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
49661     } CALL_CATCH_EXCEPTION(0);
49662   }
49663
49664   jresult = (void *)result;
49665   return jresult;
49666 }
49667
49668
49669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(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)->ShownSignal();
49678     } CALL_CATCH_EXCEPTION(0);
49679   }
49680
49681   jresult = (void *)result;
49682   return jresult;
49683 }
49684
49685
49686 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(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)->HidingSignal();
49695     } CALL_CATCH_EXCEPTION(0);
49696   }
49697
49698   jresult = (void *)result;
49699   return jresult;
49700 }
49701
49702
49703 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(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)->HiddenSignal();
49712     } CALL_CATCH_EXCEPTION(0);
49713   }
49714
49715   jresult = (void *)result;
49716   return jresult;
49717 }
49718
49719
49720 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
49721   int jresult ;
49722   int result;
49723
49724   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
49725   jresult = (int)result;
49726   return jresult;
49727 }
49728
49729
49730 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
49731   int jresult ;
49732   int result;
49733
49734   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
49735   jresult = (int)result;
49736   return jresult;
49737 }
49738
49739
49740 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
49741   int jresult ;
49742   int result;
49743
49744   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
49745   jresult = (int)result;
49746   return jresult;
49747 }
49748
49749
49750 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
49751   int jresult ;
49752   int result;
49753
49754   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
49755   jresult = (int)result;
49756   return jresult;
49757 }
49758
49759
49760 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
49761   int jresult ;
49762   int result;
49763
49764   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
49765   jresult = (int)result;
49766   return jresult;
49767 }
49768
49769
49770 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
49771   int jresult ;
49772   int result;
49773
49774   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
49775   jresult = (int)result;
49776   return jresult;
49777 }
49778
49779
49780 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
49781   int jresult ;
49782   int result;
49783
49784   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
49785   jresult = (int)result;
49786   return jresult;
49787 }
49788
49789
49790 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
49791   int jresult ;
49792   int result;
49793
49794   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
49795   jresult = (int)result;
49796   return jresult;
49797 }
49798
49799
49800 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
49801   int jresult ;
49802   int result;
49803
49804   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
49805   jresult = (int)result;
49806   return jresult;
49807 }
49808
49809
49810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
49811   void * jresult ;
49812   Dali::Toolkit::ProgressBar::Property *result = 0 ;
49813
49814   {
49815     try {
49816       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
49817     } CALL_CATCH_EXCEPTION(0);
49818   }
49819
49820   jresult = (void *)result;
49821   return jresult;
49822 }
49823
49824
49825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
49826   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
49827
49828   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
49829   {
49830     try {
49831       delete arg1;
49832     } CALL_CATCH_EXCEPTION();
49833   }
49834
49835 }
49836
49837
49838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
49839   void * jresult ;
49840   Dali::Toolkit::ProgressBar result;
49841
49842   {
49843     try {
49844       result = Dali::Toolkit::ProgressBar::New();
49845     } CALL_CATCH_EXCEPTION(0);
49846   }
49847
49848   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
49849   return jresult;
49850 }
49851
49852
49853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
49854   void * jresult ;
49855   Dali::Toolkit::ProgressBar *result = 0 ;
49856
49857   {
49858     try {
49859       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
49860     } CALL_CATCH_EXCEPTION(0);
49861   }
49862
49863   jresult = (void *)result;
49864   return jresult;
49865 }
49866
49867
49868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
49869   void * jresult ;
49870   Dali::Toolkit::ProgressBar *arg1 = 0 ;
49871   Dali::Toolkit::ProgressBar *result = 0 ;
49872
49873   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
49874   if (!arg1) {
49875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
49876     return 0;
49877   }
49878   {
49879     try {
49880       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
49881     } CALL_CATCH_EXCEPTION(0);
49882   }
49883
49884   jresult = (void *)result;
49885   return jresult;
49886 }
49887
49888
49889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
49890   void * jresult ;
49891   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
49892   Dali::Toolkit::ProgressBar *arg2 = 0 ;
49893   Dali::Toolkit::ProgressBar *result = 0 ;
49894
49895   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
49896   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
49897   if (!arg2) {
49898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
49899     return 0;
49900   }
49901   {
49902     try {
49903       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
49904     } CALL_CATCH_EXCEPTION(0);
49905   }
49906
49907   jresult = (void *)result;
49908   return jresult;
49909 }
49910
49911
49912 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
49913   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
49914
49915   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
49916   {
49917     try {
49918       delete arg1;
49919     } CALL_CATCH_EXCEPTION();
49920   }
49921
49922 }
49923
49924
49925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
49926   void * jresult ;
49927   Dali::BaseHandle arg1 ;
49928   Dali::BaseHandle *argp1 ;
49929   Dali::Toolkit::ProgressBar result;
49930
49931   argp1 = (Dali::BaseHandle *)jarg1;
49932   if (!argp1) {
49933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
49934     return 0;
49935   }
49936   arg1 = *argp1;
49937   {
49938     try {
49939       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
49940     } CALL_CATCH_EXCEPTION(0);
49941   }
49942
49943   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
49944   return jresult;
49945 }
49946
49947
49948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
49949   void * jresult ;
49950   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
49951   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
49952
49953   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
49954   {
49955     try {
49956       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
49957     } CALL_CATCH_EXCEPTION(0);
49958   }
49959
49960   jresult = (void *)result;
49961   return jresult;
49962 }
49963
49964
49965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
49966   void * jresult ;
49967   Dali::Toolkit::GaussianBlurView *result = 0 ;
49968
49969   {
49970     try {
49971       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
49972     } CALL_CATCH_EXCEPTION(0);
49973   }
49974
49975   jresult = (void *)result;
49976   return jresult;
49977 }
49978
49979
49980 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
49981   void * jresult ;
49982   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
49983   Dali::Toolkit::GaussianBlurView *result = 0 ;
49984
49985   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
49986   if (!arg1) {
49987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
49988     return 0;
49989   }
49990   {
49991     try {
49992       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
49993     } CALL_CATCH_EXCEPTION(0);
49994   }
49995
49996   jresult = (void *)result;
49997   return jresult;
49998 }
49999
50000
50001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
50002   void * jresult ;
50003   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
50004   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
50005   Dali::Toolkit::GaussianBlurView *result = 0 ;
50006
50007   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
50008   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
50009   if (!arg2) {
50010     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
50011     return 0;
50012   }
50013   {
50014     try {
50015       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
50016     } CALL_CATCH_EXCEPTION(0);
50017   }
50018
50019   jresult = (void *)result;
50020   return jresult;
50021 }
50022
50023
50024 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
50025   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
50026
50027   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
50028   {
50029     try {
50030       delete arg1;
50031     } CALL_CATCH_EXCEPTION();
50032   }
50033
50034 }
50035
50036
50037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
50038   void * jresult ;
50039   Dali::BaseHandle arg1 ;
50040   Dali::BaseHandle *argp1 ;
50041   Dali::Toolkit::GaussianBlurView result;
50042
50043   argp1 = (Dali::BaseHandle *)jarg1;
50044   if (!argp1) {
50045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
50046     return 0;
50047   }
50048   arg1 = *argp1;
50049   {
50050     try {
50051       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
50052     } CALL_CATCH_EXCEPTION(0);
50053   }
50054
50055   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
50056   return jresult;
50057 }
50058
50059
50060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
50061   void * jresult ;
50062   Dali::Toolkit::GaussianBlurView result;
50063
50064   {
50065     try {
50066       result = Dali::Toolkit::GaussianBlurView::New();
50067     } CALL_CATCH_EXCEPTION(0);
50068   }
50069
50070   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
50071   return jresult;
50072 }
50073
50074
50075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
50076   void * jresult ;
50077   unsigned int arg1 ;
50078   float arg2 ;
50079   Dali::Pixel::Format arg3 ;
50080   float arg4 ;
50081   float arg5 ;
50082   bool arg6 ;
50083   Dali::Toolkit::GaussianBlurView result;
50084
50085   arg1 = (unsigned int)jarg1;
50086   arg2 = (float)jarg2;
50087   arg3 = (Dali::Pixel::Format)jarg3;
50088   arg4 = (float)jarg4;
50089   arg5 = (float)jarg5;
50090   arg6 = jarg6 ? true : false;
50091   {
50092     try {
50093       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
50094     } CALL_CATCH_EXCEPTION(0);
50095   }
50096
50097   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
50098   return jresult;
50099 }
50100
50101
50102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
50103   void * jresult ;
50104   unsigned int arg1 ;
50105   float arg2 ;
50106   Dali::Pixel::Format arg3 ;
50107   float arg4 ;
50108   float arg5 ;
50109   Dali::Toolkit::GaussianBlurView result;
50110
50111   arg1 = (unsigned int)jarg1;
50112   arg2 = (float)jarg2;
50113   arg3 = (Dali::Pixel::Format)jarg3;
50114   arg4 = (float)jarg4;
50115   arg5 = (float)jarg5;
50116   {
50117     try {
50118       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
50119     } CALL_CATCH_EXCEPTION(0);
50120   }
50121
50122   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
50123   return jresult;
50124 }
50125
50126
50127 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
50128   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
50129   Dali::Actor arg2 ;
50130   Dali::Actor *argp2 ;
50131
50132   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
50133   argp2 = (Dali::Actor *)jarg2;
50134   if (!argp2) {
50135     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50136     return ;
50137   }
50138   arg2 = *argp2;
50139   {
50140     try {
50141       (arg1)->Add(arg2);
50142     } CALL_CATCH_EXCEPTION();
50143   }
50144
50145 }
50146
50147
50148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
50149   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
50150   Dali::Actor arg2 ;
50151   Dali::Actor *argp2 ;
50152
50153   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
50154   argp2 = (Dali::Actor *)jarg2;
50155   if (!argp2) {
50156     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50157     return ;
50158   }
50159   arg2 = *argp2;
50160   {
50161     try {
50162       (arg1)->Remove(arg2);
50163     } CALL_CATCH_EXCEPTION();
50164   }
50165
50166 }
50167
50168
50169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
50170   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
50171
50172   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
50173   {
50174     try {
50175       (arg1)->Activate();
50176     } CALL_CATCH_EXCEPTION();
50177   }
50178
50179 }
50180
50181
50182 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
50183   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
50184
50185   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
50186   {
50187     try {
50188       (arg1)->ActivateOnce();
50189     } CALL_CATCH_EXCEPTION();
50190   }
50191
50192 }
50193
50194
50195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
50196   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
50197
50198   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
50199   {
50200     try {
50201       (arg1)->Deactivate();
50202     } CALL_CATCH_EXCEPTION();
50203   }
50204
50205 }
50206
50207
50208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
50209   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
50210   Dali::Texture arg2 ;
50211   Dali::FrameBuffer arg3 ;
50212   Dali::Texture *argp2 ;
50213   Dali::FrameBuffer *argp3 ;
50214
50215   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
50216   argp2 = (Dali::Texture *)jarg2;
50217   if (!argp2) {
50218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
50219     return ;
50220   }
50221   arg2 = *argp2;
50222   argp3 = (Dali::FrameBuffer *)jarg3;
50223   if (!argp3) {
50224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
50225     return ;
50226   }
50227   arg3 = *argp3;
50228   {
50229     try {
50230       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
50231     } CALL_CATCH_EXCEPTION();
50232   }
50233
50234 }
50235
50236
50237 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
50238   int jresult ;
50239   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
50240   Dali::Property::Index result;
50241
50242   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
50243   {
50244     try {
50245       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
50246     } CALL_CATCH_EXCEPTION(0);
50247   }
50248
50249   jresult = result;
50250   return jresult;
50251 }
50252
50253
50254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
50255   void * jresult ;
50256   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
50257   Dali::FrameBuffer result;
50258
50259   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
50260   {
50261     try {
50262       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
50263     } CALL_CATCH_EXCEPTION(0);
50264   }
50265
50266   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
50267   return jresult;
50268 }
50269
50270
50271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
50272   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
50273   Dali::Vector4 *arg2 = 0 ;
50274
50275   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
50276   arg2 = (Dali::Vector4 *)jarg2;
50277   if (!arg2) {
50278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
50279     return ;
50280   }
50281   {
50282     try {
50283       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
50284     } CALL_CATCH_EXCEPTION();
50285   }
50286
50287 }
50288
50289
50290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
50291   void * jresult ;
50292   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
50293   Dali::Vector4 result;
50294
50295   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
50296   {
50297     try {
50298       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
50299     } CALL_CATCH_EXCEPTION(0);
50300   }
50301
50302   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
50303   return jresult;
50304 }
50305
50306
50307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
50308   void * jresult ;
50309   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
50310   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
50311
50312   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
50313   {
50314     try {
50315       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
50316     } CALL_CATCH_EXCEPTION(0);
50317   }
50318
50319   jresult = (void *)result;
50320   return jresult;
50321 }
50322
50323
50324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
50325   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
50326
50327   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
50328   {
50329     try {
50330       delete arg1;
50331     } CALL_CATCH_EXCEPTION();
50332   }
50333
50334 }
50335
50336
50337 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
50338   unsigned int jresult ;
50339   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
50340   unsigned int result;
50341
50342   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
50343   {
50344     try {
50345       result = (unsigned int)(arg1)->GetNumberOfPages();
50346     } CALL_CATCH_EXCEPTION(0);
50347   }
50348
50349   jresult = result;
50350   return jresult;
50351 }
50352
50353
50354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
50355   void * jresult ;
50356   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
50357   unsigned int arg2 ;
50358   Dali::Texture result;
50359
50360   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
50361   arg2 = (unsigned int)jarg2;
50362   {
50363     try {
50364       result = (arg1)->NewPage(arg2);
50365     } CALL_CATCH_EXCEPTION(0);
50366   }
50367
50368   jresult = new Dali::Texture((const Dali::Texture &)result);
50369   return jresult;
50370 }
50371
50372
50373 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_VIEW_PAGE_SIZE_get() {
50374   int jresult ;
50375   int result;
50376
50377   result = (int)Dali::Toolkit::PageTurnView::Property::VIEW_PAGE_SIZE;
50378   jresult = (int)result;
50379   return jresult;
50380 }
50381
50382
50383 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
50384   int jresult ;
50385   int result;
50386
50387   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
50388   jresult = (int)result;
50389   return jresult;
50390 }
50391
50392
50393 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
50394   int jresult ;
50395   int result;
50396
50397   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
50398   jresult = (int)result;
50399   return jresult;
50400 }
50401
50402
50403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
50404   void * jresult ;
50405   Dali::Toolkit::PageTurnView::Property *result = 0 ;
50406
50407   {
50408     try {
50409       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
50410     } CALL_CATCH_EXCEPTION(0);
50411   }
50412
50413   jresult = (void *)result;
50414   return jresult;
50415 }
50416
50417
50418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
50419   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
50420
50421   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
50422   {
50423     try {
50424       delete arg1;
50425     } CALL_CATCH_EXCEPTION();
50426   }
50427
50428 }
50429
50430
50431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
50432   void * jresult ;
50433   Dali::Toolkit::PageTurnView *result = 0 ;
50434
50435   {
50436     try {
50437       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
50438     } CALL_CATCH_EXCEPTION(0);
50439   }
50440
50441   jresult = (void *)result;
50442   return jresult;
50443 }
50444
50445
50446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
50447   void * jresult ;
50448   Dali::Toolkit::PageTurnView *arg1 = 0 ;
50449   Dali::Toolkit::PageTurnView *result = 0 ;
50450
50451   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
50452   if (!arg1) {
50453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
50454     return 0;
50455   }
50456   {
50457     try {
50458       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
50459     } CALL_CATCH_EXCEPTION(0);
50460   }
50461
50462   jresult = (void *)result;
50463   return jresult;
50464 }
50465
50466
50467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
50468   void * jresult ;
50469   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
50470   Dali::Toolkit::PageTurnView *arg2 = 0 ;
50471   Dali::Toolkit::PageTurnView *result = 0 ;
50472
50473   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
50474   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
50475   if (!arg2) {
50476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
50477     return 0;
50478   }
50479   {
50480     try {
50481       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
50482     } CALL_CATCH_EXCEPTION(0);
50483   }
50484
50485   jresult = (void *)result;
50486   return jresult;
50487 }
50488
50489
50490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
50491   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
50492
50493   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
50494   {
50495     try {
50496       delete arg1;
50497     } CALL_CATCH_EXCEPTION();
50498   }
50499
50500 }
50501
50502
50503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
50504   void * jresult ;
50505   Dali::BaseHandle arg1 ;
50506   Dali::BaseHandle *argp1 ;
50507   Dali::Toolkit::PageTurnView result;
50508
50509   argp1 = (Dali::BaseHandle *)jarg1;
50510   if (!argp1) {
50511     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
50512     return 0;
50513   }
50514   arg1 = *argp1;
50515   {
50516     try {
50517       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
50518     } CALL_CATCH_EXCEPTION(0);
50519   }
50520
50521   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
50522   return jresult;
50523 }
50524
50525
50526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
50527   void * jresult ;
50528   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
50529   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
50530
50531   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
50532   {
50533     try {
50534       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
50535     } CALL_CATCH_EXCEPTION(0);
50536   }
50537
50538   jresult = (void *)result;
50539   return jresult;
50540 }
50541
50542
50543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(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)->PageTurnFinishedSignal();
50552     } CALL_CATCH_EXCEPTION(0);
50553   }
50554
50555   jresult = (void *)result;
50556   return jresult;
50557 }
50558
50559
50560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
50561   void * jresult ;
50562   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
50563   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
50564
50565   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
50566   {
50567     try {
50568       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
50569     } CALL_CATCH_EXCEPTION(0);
50570   }
50571
50572   jresult = (void *)result;
50573   return jresult;
50574 }
50575
50576
50577 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(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)->PagePanFinishedSignal();
50586     } CALL_CATCH_EXCEPTION(0);
50587   }
50588
50589   jresult = (void *)result;
50590   return jresult;
50591 }
50592
50593
50594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
50595   void * jresult ;
50596   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
50597
50598   {
50599     try {
50600       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
50601     } CALL_CATCH_EXCEPTION(0);
50602   }
50603
50604   jresult = (void *)result;
50605   return jresult;
50606 }
50607
50608
50609 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
50610   void * jresult ;
50611   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
50612   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
50613
50614   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
50615   if (!arg1) {
50616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
50617     return 0;
50618   }
50619   {
50620     try {
50621       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
50622     } CALL_CATCH_EXCEPTION(0);
50623   }
50624
50625   jresult = (void *)result;
50626   return jresult;
50627 }
50628
50629
50630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
50631   void * jresult ;
50632   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
50633   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
50634   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
50635
50636   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
50637   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
50638   if (!arg2) {
50639     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
50640     return 0;
50641   }
50642   {
50643     try {
50644       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
50645     } CALL_CATCH_EXCEPTION(0);
50646   }
50647
50648   jresult = (void *)result;
50649   return jresult;
50650 }
50651
50652
50653 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
50654   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
50655
50656   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
50657   {
50658     try {
50659       delete arg1;
50660     } CALL_CATCH_EXCEPTION();
50661   }
50662
50663 }
50664
50665
50666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
50667   void * jresult ;
50668   Dali::Toolkit::PageFactory *arg1 = 0 ;
50669   Dali::Vector2 *arg2 = 0 ;
50670   Dali::Toolkit::PageTurnLandscapeView result;
50671
50672   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
50673   if (!arg1) {
50674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
50675     return 0;
50676   }
50677   arg2 = (Dali::Vector2 *)jarg2;
50678   if (!arg2) {
50679     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
50680     return 0;
50681   }
50682   {
50683     try {
50684       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
50685     } CALL_CATCH_EXCEPTION(0);
50686   }
50687
50688   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
50689   return jresult;
50690 }
50691
50692
50693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
50694   void * jresult ;
50695   Dali::BaseHandle arg1 ;
50696   Dali::BaseHandle *argp1 ;
50697   Dali::Toolkit::PageTurnLandscapeView result;
50698
50699   argp1 = (Dali::BaseHandle *)jarg1;
50700   if (!argp1) {
50701     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
50702     return 0;
50703   }
50704   arg1 = *argp1;
50705   {
50706     try {
50707       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
50708     } CALL_CATCH_EXCEPTION(0);
50709   }
50710
50711   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
50712   return jresult;
50713 }
50714
50715
50716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
50717   void * jresult ;
50718   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
50719
50720   {
50721     try {
50722       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
50723     } CALL_CATCH_EXCEPTION(0);
50724   }
50725
50726   jresult = (void *)result;
50727   return jresult;
50728 }
50729
50730
50731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
50732   void * jresult ;
50733   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
50734   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
50735
50736   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
50737   if (!arg1) {
50738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
50739     return 0;
50740   }
50741   {
50742     try {
50743       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
50744     } CALL_CATCH_EXCEPTION(0);
50745   }
50746
50747   jresult = (void *)result;
50748   return jresult;
50749 }
50750
50751
50752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
50753   void * jresult ;
50754   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
50755   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
50756   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
50757
50758   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
50759   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
50760   if (!arg2) {
50761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
50762     return 0;
50763   }
50764   {
50765     try {
50766       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
50767     } CALL_CATCH_EXCEPTION(0);
50768   }
50769
50770   jresult = (void *)result;
50771   return jresult;
50772 }
50773
50774
50775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
50776   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
50777
50778   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
50779   {
50780     try {
50781       delete arg1;
50782     } CALL_CATCH_EXCEPTION();
50783   }
50784
50785 }
50786
50787
50788 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
50789   void * jresult ;
50790   Dali::Toolkit::PageFactory *arg1 = 0 ;
50791   Dali::Vector2 *arg2 = 0 ;
50792   Dali::Toolkit::PageTurnPortraitView result;
50793
50794   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
50795   if (!arg1) {
50796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
50797     return 0;
50798   }
50799   arg2 = (Dali::Vector2 *)jarg2;
50800   if (!arg2) {
50801     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
50802     return 0;
50803   }
50804   {
50805     try {
50806       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
50807     } CALL_CATCH_EXCEPTION(0);
50808   }
50809
50810   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
50811   return jresult;
50812 }
50813
50814
50815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
50816   void * jresult ;
50817   Dali::BaseHandle arg1 ;
50818   Dali::BaseHandle *argp1 ;
50819   Dali::Toolkit::PageTurnPortraitView result;
50820
50821   argp1 = (Dali::BaseHandle *)jarg1;
50822   if (!argp1) {
50823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
50824     return 0;
50825   }
50826   arg1 = *argp1;
50827   {
50828     try {
50829       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
50830     } CALL_CATCH_EXCEPTION(0);
50831   }
50832
50833   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
50834   return jresult;
50835 }
50836
50837
50838 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
50839   int jresult ;
50840   int result;
50841
50842   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
50843   jresult = (int)result;
50844   return jresult;
50845 }
50846
50847
50848 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
50849   int jresult ;
50850   int result;
50851
50852   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
50853   jresult = (int)result;
50854   return jresult;
50855 }
50856
50857
50858 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
50859   int jresult ;
50860   int result;
50861
50862   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
50863   jresult = (int)result;
50864   return jresult;
50865 }
50866
50867
50868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
50869   void * jresult ;
50870   Dali::Toolkit::ToggleButton::Property *result = 0 ;
50871
50872   {
50873     try {
50874       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
50875     } CALL_CATCH_EXCEPTION(0);
50876   }
50877
50878   jresult = (void *)result;
50879   return jresult;
50880 }
50881
50882
50883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
50884   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
50885
50886   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
50887   {
50888     try {
50889       delete arg1;
50890     } CALL_CATCH_EXCEPTION();
50891   }
50892
50893 }
50894
50895
50896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
50897   void * jresult ;
50898   Dali::Toolkit::ToggleButton *result = 0 ;
50899
50900   {
50901     try {
50902       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
50903     } CALL_CATCH_EXCEPTION(0);
50904   }
50905
50906   jresult = (void *)result;
50907   return jresult;
50908 }
50909
50910
50911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
50912   void * jresult ;
50913   Dali::Toolkit::ToggleButton *arg1 = 0 ;
50914   Dali::Toolkit::ToggleButton *result = 0 ;
50915
50916   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
50917   if (!arg1) {
50918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
50919     return 0;
50920   }
50921   {
50922     try {
50923       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
50924     } CALL_CATCH_EXCEPTION(0);
50925   }
50926
50927   jresult = (void *)result;
50928   return jresult;
50929 }
50930
50931
50932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
50933   void * jresult ;
50934   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
50935   Dali::Toolkit::ToggleButton *arg2 = 0 ;
50936   Dali::Toolkit::ToggleButton *result = 0 ;
50937
50938   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
50939   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
50940   if (!arg2) {
50941     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
50942     return 0;
50943   }
50944   {
50945     try {
50946       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
50947     } CALL_CATCH_EXCEPTION(0);
50948   }
50949
50950   jresult = (void *)result;
50951   return jresult;
50952 }
50953
50954
50955 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
50956   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
50957
50958   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
50959   {
50960     try {
50961       delete arg1;
50962     } CALL_CATCH_EXCEPTION();
50963   }
50964
50965 }
50966
50967
50968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
50969   void * jresult ;
50970   Dali::Toolkit::ToggleButton result;
50971
50972   {
50973     try {
50974       result = Dali::Toolkit::ToggleButton::New();
50975     } CALL_CATCH_EXCEPTION(0);
50976   }
50977
50978   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
50979   return jresult;
50980 }
50981
50982
50983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
50984   void * jresult ;
50985   Dali::BaseHandle arg1 ;
50986   Dali::BaseHandle *argp1 ;
50987   Dali::Toolkit::ToggleButton result;
50988
50989   argp1 = (Dali::BaseHandle *)jarg1;
50990   if (!argp1) {
50991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
50992     return 0;
50993   }
50994   arg1 = *argp1;
50995   {
50996     try {
50997       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
50998     } CALL_CATCH_EXCEPTION(0);
50999   }
51000
51001   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
51002   return jresult;
51003 }
51004
51005
51006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
51007   void * jresult ;
51008   Dali::Toolkit::Visual::Base *result = 0 ;
51009
51010   {
51011     try {
51012       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
51013     } CALL_CATCH_EXCEPTION(0);
51014   }
51015
51016   jresult = (void *)result;
51017   return jresult;
51018 }
51019
51020
51021 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
51022   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
51023
51024   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
51025   {
51026     try {
51027       delete arg1;
51028     } CALL_CATCH_EXCEPTION();
51029   }
51030
51031 }
51032
51033
51034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
51035   void * jresult ;
51036   Dali::Toolkit::Visual::Base *arg1 = 0 ;
51037   Dali::Toolkit::Visual::Base *result = 0 ;
51038
51039   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
51040   if (!arg1) {
51041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
51042     return 0;
51043   }
51044   {
51045     try {
51046       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
51047     } CALL_CATCH_EXCEPTION(0);
51048   }
51049
51050   jresult = (void *)result;
51051   return jresult;
51052 }
51053
51054
51055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
51056   void * jresult ;
51057   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
51058   Dali::Toolkit::Visual::Base *arg2 = 0 ;
51059   Dali::Toolkit::Visual::Base *result = 0 ;
51060
51061   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
51062   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
51063   if (!arg2) {
51064     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
51065     return 0;
51066   }
51067   {
51068     try {
51069       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
51070     } CALL_CATCH_EXCEPTION(0);
51071   }
51072
51073   jresult = (void *)result;
51074   return jresult;
51075 }
51076
51077
51078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
51079   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
51080   std::string *arg2 = 0 ;
51081
51082   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
51083   if (!jarg2) {
51084     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
51085     return ;
51086   }
51087   std::string arg2_str(jarg2);
51088   arg2 = &arg2_str;
51089   {
51090     try {
51091       (arg1)->SetName((std::string const &)*arg2);
51092     } CALL_CATCH_EXCEPTION();
51093   }
51094
51095
51096   //argout typemap for const std::string&
51097
51098 }
51099
51100
51101 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
51102   char * jresult ;
51103   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
51104   std::string *result = 0 ;
51105
51106   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
51107   {
51108     try {
51109       result = (std::string *) &(arg1)->GetName();
51110     } CALL_CATCH_EXCEPTION(0);
51111   }
51112
51113   jresult = SWIG_csharp_string_callback(result->c_str());
51114   return jresult;
51115 }
51116
51117
51118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
51119   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
51120   Dali::Property::Map *arg2 = 0 ;
51121   Dali::Size arg3 ;
51122   Dali::Size *argp3 ;
51123
51124   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
51125   arg2 = (Dali::Property::Map *)jarg2;
51126   if (!arg2) {
51127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
51128     return ;
51129   }
51130   argp3 = (Dali::Size *)jarg3;
51131   if (!argp3) {
51132     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
51133     return ;
51134   }
51135   arg3 = *argp3;
51136   {
51137     try {
51138       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
51139     } CALL_CATCH_EXCEPTION();
51140   }
51141
51142 }
51143
51144
51145 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
51146   float jresult ;
51147   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
51148   float arg2 ;
51149   float result;
51150
51151   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
51152   arg2 = (float)jarg2;
51153   {
51154     try {
51155       result = (float)(arg1)->GetHeightForWidth(arg2);
51156     } CALL_CATCH_EXCEPTION(0);
51157   }
51158
51159   jresult = result;
51160   return jresult;
51161 }
51162
51163
51164 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
51165   float jresult ;
51166   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
51167   float arg2 ;
51168   float result;
51169
51170   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
51171   arg2 = (float)jarg2;
51172   {
51173     try {
51174       result = (float)(arg1)->GetWidthForHeight(arg2);
51175     } CALL_CATCH_EXCEPTION(0);
51176   }
51177
51178   jresult = result;
51179   return jresult;
51180 }
51181
51182
51183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
51184   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
51185   Dali::Vector2 *arg2 = 0 ;
51186
51187   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
51188   arg2 = (Dali::Vector2 *)jarg2;
51189   if (!arg2) {
51190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
51191     return ;
51192   }
51193   {
51194     try {
51195       (arg1)->GetNaturalSize(*arg2);
51196     } CALL_CATCH_EXCEPTION();
51197   }
51198
51199 }
51200
51201
51202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, int jarg2) {
51203   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
51204   float arg2 ;
51205
51206   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
51207   arg2 = (int)jarg2;
51208   {
51209     try {
51210       (arg1)->SetDepthIndex(arg2);
51211     } CALL_CATCH_EXCEPTION();
51212   }
51213
51214 }
51215
51216
51217 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
51218   int jresult ;
51219   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
51220   int result;
51221
51222   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
51223   {
51224     try {
51225       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
51226     } CALL_CATCH_EXCEPTION(0);
51227   }
51228
51229   jresult = result;
51230   return jresult;
51231 }
51232
51233
51234 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
51235   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
51236   Dali::Property::Map *arg2 = 0 ;
51237
51238   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
51239   arg2 = (Dali::Property::Map *)jarg2;
51240   if (!arg2) {
51241     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
51242     return ;
51243   }
51244   {
51245     try {
51246       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
51247     } CALL_CATCH_EXCEPTION();
51248   }
51249
51250 }
51251
51252
51253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
51254   void * jresult ;
51255   Dali::Toolkit::VisualFactory result;
51256
51257   {
51258     try {
51259       result = Dali::Toolkit::VisualFactory::Get();
51260     } CALL_CATCH_EXCEPTION(0);
51261   }
51262
51263   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
51264   return jresult;
51265 }
51266
51267
51268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
51269   void * jresult ;
51270   Dali::Toolkit::VisualFactory *result = 0 ;
51271
51272   {
51273     try {
51274       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
51275     } CALL_CATCH_EXCEPTION(0);
51276   }
51277
51278   jresult = (void *)result;
51279   return jresult;
51280 }
51281
51282
51283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
51284   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
51285
51286   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
51287   {
51288     try {
51289       delete arg1;
51290     } CALL_CATCH_EXCEPTION();
51291   }
51292
51293 }
51294
51295
51296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
51297   void * jresult ;
51298   Dali::Toolkit::VisualFactory *arg1 = 0 ;
51299   Dali::Toolkit::VisualFactory *result = 0 ;
51300
51301   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
51302   if (!arg1) {
51303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
51304     return 0;
51305   }
51306   {
51307     try {
51308       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
51309     } CALL_CATCH_EXCEPTION(0);
51310   }
51311
51312   jresult = (void *)result;
51313   return jresult;
51314 }
51315
51316
51317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
51318   void * jresult ;
51319   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
51320   Dali::Toolkit::VisualFactory *arg2 = 0 ;
51321   Dali::Toolkit::VisualFactory *result = 0 ;
51322
51323   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
51324   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
51325   if (!arg2) {
51326     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
51327     return 0;
51328   }
51329   {
51330     try {
51331       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
51332     } CALL_CATCH_EXCEPTION(0);
51333   }
51334
51335   jresult = (void *)result;
51336   return jresult;
51337 }
51338
51339
51340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
51341   void * jresult ;
51342   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
51343   Dali::Property::Map *arg2 = 0 ;
51344   Dali::Toolkit::Visual::Base result;
51345
51346   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
51347   arg2 = (Dali::Property::Map *)jarg2;
51348   if (!arg2) {
51349     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
51350     return 0;
51351   }
51352   {
51353     try {
51354       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
51355     } CALL_CATCH_EXCEPTION(0);
51356   }
51357
51358   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
51359   return jresult;
51360 }
51361
51362
51363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
51364   void * jresult ;
51365   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
51366   std::string *arg2 = 0 ;
51367   Dali::ImageDimensions arg3 ;
51368   Dali::ImageDimensions *argp3 ;
51369   Dali::Toolkit::Visual::Base result;
51370
51371   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
51372   if (!jarg2) {
51373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
51374     return 0;
51375   }
51376   std::string arg2_str(jarg2);
51377   arg2 = &arg2_str;
51378   argp3 = (Dali::ImageDimensions *)jarg3;
51379   if (!argp3) {
51380     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
51381     return 0;
51382   }
51383   arg3 = *argp3;
51384   {
51385     try {
51386       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
51387     } CALL_CATCH_EXCEPTION(0);
51388   }
51389
51390   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
51391
51392   //argout typemap for const std::string&
51393
51394   return jresult;
51395 }
51396
51397
51398 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
51399   void * jresult ;
51400   Dali::Toolkit::AsyncImageLoader *result = 0 ;
51401
51402   {
51403     try {
51404       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
51405     } CALL_CATCH_EXCEPTION(0);
51406   }
51407
51408   jresult = (void *)result;
51409   return jresult;
51410 }
51411
51412
51413 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
51414   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
51415
51416   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
51417   {
51418     try {
51419       delete arg1;
51420     } CALL_CATCH_EXCEPTION();
51421   }
51422
51423 }
51424
51425
51426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
51427   void * jresult ;
51428   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
51429   Dali::Toolkit::AsyncImageLoader *result = 0 ;
51430
51431   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
51432   if (!arg1) {
51433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
51434     return 0;
51435   }
51436   {
51437     try {
51438       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
51439     } CALL_CATCH_EXCEPTION(0);
51440   }
51441
51442   jresult = (void *)result;
51443   return jresult;
51444 }
51445
51446
51447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
51448   void * jresult ;
51449   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
51450   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
51451   Dali::Toolkit::AsyncImageLoader *result = 0 ;
51452
51453   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
51454   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
51455   if (!arg2) {
51456     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
51457     return 0;
51458   }
51459   {
51460     try {
51461       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
51462     } CALL_CATCH_EXCEPTION(0);
51463   }
51464
51465   jresult = (void *)result;
51466   return jresult;
51467 }
51468
51469
51470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
51471   void * jresult ;
51472   Dali::Toolkit::AsyncImageLoader result;
51473
51474   {
51475     try {
51476       result = Dali::Toolkit::AsyncImageLoader::New();
51477     } CALL_CATCH_EXCEPTION(0);
51478   }
51479
51480   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
51481   return jresult;
51482 }
51483
51484
51485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
51486   void * jresult ;
51487   Dali::BaseHandle arg1 ;
51488   Dali::BaseHandle *argp1 ;
51489   Dali::Toolkit::AsyncImageLoader result;
51490
51491   argp1 = (Dali::BaseHandle *)jarg1;
51492   if (!argp1) {
51493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
51494     return 0;
51495   }
51496   arg1 = *argp1;
51497   {
51498     try {
51499       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
51500     } CALL_CATCH_EXCEPTION(0);
51501   }
51502
51503   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
51504   return jresult;
51505 }
51506
51507
51508 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
51509   unsigned int jresult ;
51510   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
51511   std::string *arg2 = 0 ;
51512   uint32_t result;
51513
51514   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
51515   if (!jarg2) {
51516     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
51517     return 0;
51518   }
51519   std::string arg2_str(jarg2);
51520   arg2 = &arg2_str;
51521   {
51522     try {
51523       result = (arg1)->Load((std::string const &)*arg2);
51524     } CALL_CATCH_EXCEPTION(0);
51525   }
51526
51527   jresult = result;
51528
51529   //argout typemap for const std::string&
51530
51531   return jresult;
51532 }
51533
51534
51535 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
51536   unsigned int jresult ;
51537   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
51538   std::string *arg2 = 0 ;
51539   Dali::ImageDimensions arg3 ;
51540   Dali::ImageDimensions *argp3 ;
51541   uint32_t result;
51542
51543   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
51544   if (!jarg2) {
51545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
51546     return 0;
51547   }
51548   std::string arg2_str(jarg2);
51549   arg2 = &arg2_str;
51550   argp3 = (Dali::ImageDimensions *)jarg3;
51551   if (!argp3) {
51552     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
51553     return 0;
51554   }
51555   arg3 = *argp3;
51556   {
51557     try {
51558       result = (arg1)->Load((std::string const &)*arg2,arg3);
51559     } CALL_CATCH_EXCEPTION(0);
51560   }
51561
51562   jresult = result;
51563
51564   //argout typemap for const std::string&
51565
51566   return jresult;
51567 }
51568
51569
51570 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
51571   unsigned int jresult ;
51572   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
51573   std::string *arg2 = 0 ;
51574   Dali::ImageDimensions arg3 ;
51575   Dali::FittingMode::Type arg4 ;
51576   Dali::SamplingMode::Type arg5 ;
51577   bool arg6 ;
51578   Dali::ImageDimensions *argp3 ;
51579   uint32_t result;
51580
51581   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
51582   if (!jarg2) {
51583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
51584     return 0;
51585   }
51586   std::string arg2_str(jarg2);
51587   arg2 = &arg2_str;
51588   argp3 = (Dali::ImageDimensions *)jarg3;
51589   if (!argp3) {
51590     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
51591     return 0;
51592   }
51593   arg3 = *argp3;
51594   arg4 = (Dali::FittingMode::Type)jarg4;
51595   arg5 = (Dali::SamplingMode::Type)jarg5;
51596   arg6 = jarg6 ? true : false;
51597   {
51598     try {
51599       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
51600     } CALL_CATCH_EXCEPTION(0);
51601   }
51602
51603   jresult = result;
51604
51605   //argout typemap for const std::string&
51606
51607   return jresult;
51608 }
51609
51610
51611 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
51612   unsigned int jresult ;
51613   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
51614   uint32_t arg2 ;
51615   bool result;
51616
51617   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
51618   arg2 = (uint32_t)jarg2;
51619   {
51620     try {
51621       result = (bool)(arg1)->Cancel(arg2);
51622     } CALL_CATCH_EXCEPTION(0);
51623   }
51624
51625   jresult = result;
51626   return jresult;
51627 }
51628
51629
51630 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
51631   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
51632
51633   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
51634   {
51635     try {
51636       (arg1)->CancelAll();
51637     } CALL_CATCH_EXCEPTION();
51638   }
51639
51640 }
51641
51642
51643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
51644   void * jresult ;
51645   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
51646   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
51647
51648   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
51649   {
51650     try {
51651       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
51652     } CALL_CATCH_EXCEPTION(0);
51653   }
51654
51655   jresult = (void *)result;
51656   return jresult;
51657 }
51658
51659
51660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
51661   void * jresult ;
51662   std::string *arg1 = 0 ;
51663   Dali::PixelData result;
51664
51665   if (!jarg1) {
51666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
51667     return 0;
51668   }
51669   std::string arg1_str(jarg1);
51670   arg1 = &arg1_str;
51671   {
51672     try {
51673       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
51674     } CALL_CATCH_EXCEPTION(0);
51675   }
51676
51677   jresult = new Dali::PixelData((const Dali::PixelData &)result);
51678
51679   //argout typemap for const std::string&
51680
51681   return jresult;
51682 }
51683
51684
51685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
51686   void * jresult ;
51687   std::string *arg1 = 0 ;
51688   Dali::ImageDimensions arg2 ;
51689   Dali::ImageDimensions *argp2 ;
51690   Dali::PixelData result;
51691
51692   if (!jarg1) {
51693     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
51694     return 0;
51695   }
51696   std::string arg1_str(jarg1);
51697   arg1 = &arg1_str;
51698   argp2 = (Dali::ImageDimensions *)jarg2;
51699   if (!argp2) {
51700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
51701     return 0;
51702   }
51703   arg2 = *argp2;
51704   {
51705     try {
51706       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
51707     } CALL_CATCH_EXCEPTION(0);
51708   }
51709
51710   jresult = new Dali::PixelData((const Dali::PixelData &)result);
51711
51712   //argout typemap for const std::string&
51713
51714   return jresult;
51715 }
51716
51717
51718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
51719   void * jresult ;
51720   std::string *arg1 = 0 ;
51721   Dali::ImageDimensions arg2 ;
51722   Dali::FittingMode::Type arg3 ;
51723   Dali::SamplingMode::Type arg4 ;
51724   bool arg5 ;
51725   Dali::ImageDimensions *argp2 ;
51726   Dali::PixelData result;
51727
51728   if (!jarg1) {
51729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
51730     return 0;
51731   }
51732   std::string arg1_str(jarg1);
51733   arg1 = &arg1_str;
51734   argp2 = (Dali::ImageDimensions *)jarg2;
51735   if (!argp2) {
51736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
51737     return 0;
51738   }
51739   arg2 = *argp2;
51740   arg3 = (Dali::FittingMode::Type)jarg3;
51741   arg4 = (Dali::SamplingMode::Type)jarg4;
51742   arg5 = jarg5 ? true : false;
51743   {
51744     try {
51745       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
51746     } CALL_CATCH_EXCEPTION(0);
51747   }
51748
51749   jresult = new Dali::PixelData((const Dali::PixelData &)result);
51750
51751   //argout typemap for const std::string&
51752
51753   return jresult;
51754 }
51755
51756
51757 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
51758   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
51759
51760   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
51761   {
51762     try {
51763       delete arg1;
51764     } CALL_CATCH_EXCEPTION();
51765   }
51766
51767 }
51768
51769
51770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
51771   void * jresult ;
51772   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
51773   Dali::Actor arg2 ;
51774   Dali::Actor arg3 ;
51775   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
51776   Dali::Actor *argp2 ;
51777   Dali::Actor *argp3 ;
51778   Dali::Actor result;
51779
51780   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
51781   argp2 = (Dali::Actor *)jarg2;
51782   if (!argp2) {
51783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51784     return 0;
51785   }
51786   arg2 = *argp2;
51787   argp3 = (Dali::Actor *)jarg3;
51788   if (!argp3) {
51789     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51790     return 0;
51791   }
51792   arg3 = *argp3;
51793   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
51794   {
51795     try {
51796       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4);
51797     } CALL_CATCH_EXCEPTION(0);
51798   }
51799
51800   jresult = new Dali::Actor((const Dali::Actor &)result);
51801   return jresult;
51802 }
51803
51804
51805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
51806   void * jresult ;
51807   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
51808
51809   {
51810     try {
51811       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
51812     } CALL_CATCH_EXCEPTION(0);
51813   }
51814
51815   jresult = (void *)result;
51816   return jresult;
51817 }
51818
51819
51820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_director_connect(void *objarg, SwigDirector_FrameCallbackInterface::SWIG_Callback0_t callback0) {
51821   Dali::FrameCallbackInterface *obj = (Dali::FrameCallbackInterface *)objarg;
51822   SwigDirector_FrameCallbackInterface *director = dynamic_cast<SwigDirector_FrameCallbackInterface *>(obj);
51823   if (director) {
51824     director->swig_connect_director(callback0);
51825   }
51826 }
51827
51828
51829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameCallbackInterface() {
51830   void * jresult ;
51831   Dali::FrameCallbackInterface *result = 0 ;
51832
51833   {
51834     try {
51835       result =(Dali::FrameCallbackInterface *) new SwigDirector_FrameCallbackInterface();
51836     } CALL_CATCH_EXCEPTION(0);
51837   }
51838
51839   jresult = (void *)result;
51840   return jresult;
51841 }
51842
51843 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetPosition(void * updateProxy, unsigned int id,  void* position) {
51844   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
51845   Dali::Vector3* vector3 = (Dali::Vector3 *)position;
51846   return proxy->GetPosition(id, *vector3);
51847 }
51848
51849 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetPosition(void * updateProxy, unsigned int id, void* position) {
51850   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
51851   Dali::Vector3* vector3 = (Dali::Vector3 *)position;
51852   return proxy->SetPosition(id, *vector3);
51853 }
51854
51855 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakePosition(void * updateProxy, unsigned int id, void* position) {
51856   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
51857   Dali::Vector3* vector3 = (Dali::Vector3 *)position;
51858   return proxy->BakePosition(id, *vector3);
51859 }
51860
51861 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetSize(void * updateProxy, unsigned int id, void* size) {
51862   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
51863   Dali::Vector3* vector3 = (Dali::Vector3 *)size;
51864   return proxy->GetSize(id, *vector3);
51865 }
51866
51867 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetSize(void * updateProxy, unsigned int id, void* size) {
51868   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
51869   Dali::Vector3* vector3 = (Dali::Vector3 *)size;
51870   return proxy->SetSize(id, *vector3);
51871 }
51872 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakeSize(void * updateProxy, unsigned int id, void* size) {
51873   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
51874   Dali::Vector3* vector3 = (Dali::Vector3 *)size;
51875   return proxy->BakeSize(id, *vector3);
51876 }
51877
51878 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetPositionAndSize(void * updateProxy, unsigned int id, void* position, void* size) {
51879   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
51880   Dali::Vector3* vector3_pos = (Dali::Vector3 *)position;
51881   Dali::Vector3* vector3_size = (Dali::Vector3 *)size;
51882   return proxy->GetPositionAndSize(id, *vector3_pos, *vector3_size);
51883 }
51884
51885 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetScale(void * updateProxy, unsigned int id, void* scale) {
51886   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
51887   Dali::Vector3* vector3 = (Dali::Vector3 *)scale;
51888   return proxy->GetScale(id,* vector3);
51889 }
51890
51891 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetScale(void * updateProxy, unsigned int id, void* scale) {
51892   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
51893   Dali::Vector3* vector3 = (Dali::Vector3 *)scale;
51894   return proxy->SetScale(id, *vector3);
51895 }
51896
51897 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakeScale(void * updateProxy, unsigned int id, void* scale) {
51898   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
51899   Dali::Vector3* vector3 = (Dali::Vector3 *)scale;
51900   return proxy->BakeScale(id, *vector3);
51901 }
51902
51903 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetColor(void * updateProxy, unsigned int id, void* color) {
51904   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
51905   Dali::Vector4* vector4 = (Dali::Vector4 *)color;
51906   return proxy->GetColor(id, *vector4);
51907 }
51908
51909 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetColor(void * updateProxy, unsigned int id, void* color) {
51910   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
51911   Dali::Vector4* vector4 = (Dali::Vector4 *)color;
51912   return proxy->SetColor(id, *vector4);
51913 }
51914
51915 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakeColor(void * updateProxy, unsigned int id, void* color) {
51916   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
51917   Dali::Vector4* vector4 = (Dali::Vector4 *)color;
51918   return proxy->BakeColor(id, *vector4);
51919 }
51920
51921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_AddFrameCallback(void * jarg1, void* jarg2, void* jarg3) {
51922   Dali::FrameCallbackInterface *obj = (Dali::FrameCallbackInterface *)jarg2;
51923   SwigDirector_FrameCallbackInterface *arg2 = dynamic_cast<SwigDirector_FrameCallbackInterface *>(obj);
51924
51925   Dali::Stage *arg1 = (Dali::Stage *) 0;
51926   Dali::Actor *arg3 = 0;
51927
51928   arg1 = (Dali::Stage *)jarg1;
51929   arg3 = (Dali::Actor *)jarg3;
51930
51931   DevelStage::AddFrameCallback( *arg1, *arg2, *arg3 );
51932   return;
51933 }
51934
51935 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_RemoveFrameCallback(void * jarg1, void* jarg2) {
51936
51937   Dali::FrameCallbackInterface *obj = (Dali::FrameCallbackInterface *)jarg2;
51938   SwigDirector_FrameCallbackInterface *arg2 = dynamic_cast<SwigDirector_FrameCallbackInterface *>(obj);
51939
51940   Dali::Stage *arg1 = (Dali::Stage *) 0;
51941
51942   arg1 = (Dali::Stage *)jarg1;
51943
51944   DevelStage::RemoveFrameCallback( *arg1, *arg2 );
51945   return;
51946 }
51947
51948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
51949   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
51950   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
51951   if (director) {
51952     director->swig_connect_director(callback0);
51953   }
51954 }
51955
51956 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
51957   KeyboardFocusManager arg1 ;
51958   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
51959   KeyboardFocusManager *argp1 ;
51960
51961   argp1 = (KeyboardFocusManager *)jarg1;
51962   if (!argp1) {
51963     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
51964     return ;
51965   }
51966   arg1 = *argp1;
51967   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
51968   //Null checking of arg2 is removed. arg2's null set means resetting so it can be a null value.
51969   {
51970     try {
51971       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
51972     } CALL_CATCH_EXCEPTION();
51973   }
51974
51975 }
51976
51977
51978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
51979   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
51980
51981   arg1 = (std::vector< unsigned int > *)jarg1;
51982   {
51983     try {
51984       (arg1)->clear();
51985     } CALL_CATCH_EXCEPTION();
51986   }
51987
51988 }
51989
51990
51991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
51992   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
51993   unsigned int *arg2 = 0 ;
51994   unsigned int temp2 ;
51995
51996   arg1 = (std::vector< unsigned int > *)jarg1;
51997   temp2 = (unsigned int)jarg2;
51998   arg2 = &temp2;
51999   {
52000     try {
52001       (arg1)->push_back((unsigned int const &)*arg2);
52002     } CALL_CATCH_EXCEPTION();
52003   }
52004
52005 }
52006
52007
52008 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
52009   unsigned long jresult ;
52010   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52011   std::vector< unsigned int >::size_type result;
52012
52013   arg1 = (std::vector< unsigned int > *)jarg1;
52014   {
52015     try {
52016       result = ((std::vector< unsigned int > const *)arg1)->size();
52017     } CALL_CATCH_EXCEPTION(0);
52018   }
52019
52020   jresult = (unsigned long)result;
52021   return jresult;
52022 }
52023
52024
52025 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(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)->capacity();
52034     } CALL_CATCH_EXCEPTION(0);
52035   }
52036
52037   jresult = (unsigned long)result;
52038   return jresult;
52039 }
52040
52041
52042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
52043   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52044   std::vector< unsigned int >::size_type arg2 ;
52045
52046   arg1 = (std::vector< unsigned int > *)jarg1;
52047   arg2 = (std::vector< unsigned int >::size_type)jarg2;
52048   {
52049     try {
52050       (arg1)->reserve(arg2);
52051     } CALL_CATCH_EXCEPTION();
52052   }
52053
52054 }
52055
52056
52057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
52058   void * jresult ;
52059   std::vector< unsigned int > *result = 0 ;
52060
52061   {
52062     try {
52063       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
52064     } CALL_CATCH_EXCEPTION(0);
52065   }
52066
52067   jresult = (void *)result;
52068   return jresult;
52069 }
52070
52071
52072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
52073   void * jresult ;
52074   std::vector< unsigned int > *arg1 = 0 ;
52075   std::vector< unsigned int > *result = 0 ;
52076
52077   arg1 = (std::vector< unsigned int > *)jarg1;
52078   if (!arg1) {
52079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
52080     return 0;
52081   }
52082   {
52083     try {
52084       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
52085     } CALL_CATCH_EXCEPTION(0);
52086   }
52087
52088   jresult = (void *)result;
52089   return jresult;
52090 }
52091
52092
52093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
52094   void * jresult ;
52095   int arg1 ;
52096   std::vector< unsigned int > *result = 0 ;
52097
52098   arg1 = (int)jarg1;
52099   {
52100     try {
52101       try {
52102         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
52103       }
52104       catch(std::out_of_range &_e) {
52105         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52106         return 0;
52107       }
52108
52109     } CALL_CATCH_EXCEPTION(0);
52110   }
52111
52112   jresult = (void *)result;
52113   return jresult;
52114 }
52115
52116
52117 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
52118   unsigned int jresult ;
52119   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52120   int arg2 ;
52121   unsigned int result;
52122
52123   arg1 = (std::vector< unsigned int > *)jarg1;
52124   arg2 = (int)jarg2;
52125   {
52126     try {
52127       try {
52128         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
52129       }
52130       catch(std::out_of_range &_e) {
52131         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52132         return 0;
52133       }
52134
52135     } CALL_CATCH_EXCEPTION(0);
52136   }
52137
52138   jresult = result;
52139   return jresult;
52140 }
52141
52142
52143 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
52144   unsigned int jresult ;
52145   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52146   int arg2 ;
52147   unsigned int *result = 0 ;
52148
52149   arg1 = (std::vector< unsigned int > *)jarg1;
52150   arg2 = (int)jarg2;
52151   {
52152     try {
52153       try {
52154         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
52155       }
52156       catch(std::out_of_range &_e) {
52157         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52158         return 0;
52159       }
52160
52161     } CALL_CATCH_EXCEPTION(0);
52162   }
52163
52164   jresult = *result;
52165   return jresult;
52166 }
52167
52168
52169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
52170   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52171   int arg2 ;
52172   unsigned int *arg3 = 0 ;
52173   unsigned int temp3 ;
52174
52175   arg1 = (std::vector< unsigned int > *)jarg1;
52176   arg2 = (int)jarg2;
52177   temp3 = (unsigned int)jarg3;
52178   arg3 = &temp3;
52179   {
52180     try {
52181       try {
52182         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
52183       }
52184       catch(std::out_of_range &_e) {
52185         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52186         return ;
52187       }
52188
52189     } CALL_CATCH_EXCEPTION();
52190   }
52191
52192 }
52193
52194
52195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
52196   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52197   std::vector< unsigned int > *arg2 = 0 ;
52198
52199   arg1 = (std::vector< unsigned int > *)jarg1;
52200   arg2 = (std::vector< unsigned int > *)jarg2;
52201   if (!arg2) {
52202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
52203     return ;
52204   }
52205   {
52206     try {
52207       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
52208     } CALL_CATCH_EXCEPTION();
52209   }
52210
52211 }
52212
52213
52214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
52215   void * jresult ;
52216   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52217   int arg2 ;
52218   int arg3 ;
52219   std::vector< unsigned int > *result = 0 ;
52220
52221   arg1 = (std::vector< unsigned int > *)jarg1;
52222   arg2 = (int)jarg2;
52223   arg3 = (int)jarg3;
52224   {
52225     try {
52226       try {
52227         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
52228       }
52229       catch(std::out_of_range &_e) {
52230         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52231         return 0;
52232       }
52233       catch(std::invalid_argument &_e) {
52234         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
52235         return 0;
52236       }
52237
52238     } CALL_CATCH_EXCEPTION(0);
52239   }
52240
52241   jresult = (void *)result;
52242   return jresult;
52243 }
52244
52245
52246 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
52247   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52248   int arg2 ;
52249   unsigned int *arg3 = 0 ;
52250   unsigned int temp3 ;
52251
52252   arg1 = (std::vector< unsigned int > *)jarg1;
52253   arg2 = (int)jarg2;
52254   temp3 = (unsigned int)jarg3;
52255   arg3 = &temp3;
52256   {
52257     try {
52258       try {
52259         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
52260       }
52261       catch(std::out_of_range &_e) {
52262         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52263         return ;
52264       }
52265
52266     } CALL_CATCH_EXCEPTION();
52267   }
52268
52269 }
52270
52271
52272 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
52273   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52274   int arg2 ;
52275   std::vector< unsigned int > *arg3 = 0 ;
52276
52277   arg1 = (std::vector< unsigned int > *)jarg1;
52278   arg2 = (int)jarg2;
52279   arg3 = (std::vector< unsigned int > *)jarg3;
52280   if (!arg3) {
52281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
52282     return ;
52283   }
52284   {
52285     try {
52286       try {
52287         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
52288       }
52289       catch(std::out_of_range &_e) {
52290         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52291         return ;
52292       }
52293
52294     } CALL_CATCH_EXCEPTION();
52295   }
52296
52297 }
52298
52299
52300 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
52301   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52302   int arg2 ;
52303
52304   arg1 = (std::vector< unsigned int > *)jarg1;
52305   arg2 = (int)jarg2;
52306   {
52307     try {
52308       try {
52309         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
52310       }
52311       catch(std::out_of_range &_e) {
52312         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52313         return ;
52314       }
52315
52316     } CALL_CATCH_EXCEPTION();
52317   }
52318
52319 }
52320
52321
52322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
52323   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52324   int arg2 ;
52325   int arg3 ;
52326
52327   arg1 = (std::vector< unsigned int > *)jarg1;
52328   arg2 = (int)jarg2;
52329   arg3 = (int)jarg3;
52330   {
52331     try {
52332       try {
52333         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
52334       }
52335       catch(std::out_of_range &_e) {
52336         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52337         return ;
52338       }
52339       catch(std::invalid_argument &_e) {
52340         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
52341         return ;
52342       }
52343
52344     } CALL_CATCH_EXCEPTION();
52345   }
52346
52347 }
52348
52349
52350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
52351   void * jresult ;
52352   unsigned int *arg1 = 0 ;
52353   int arg2 ;
52354   unsigned int temp1 ;
52355   std::vector< unsigned int > *result = 0 ;
52356
52357   temp1 = (unsigned int)jarg1;
52358   arg1 = &temp1;
52359   arg2 = (int)jarg2;
52360   {
52361     try {
52362       try {
52363         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
52364       }
52365       catch(std::out_of_range &_e) {
52366         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52367         return 0;
52368       }
52369
52370     } CALL_CATCH_EXCEPTION(0);
52371   }
52372
52373   jresult = (void *)result;
52374   return jresult;
52375 }
52376
52377
52378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
52379   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52380
52381   arg1 = (std::vector< unsigned int > *)jarg1;
52382   {
52383     try {
52384       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
52385     } CALL_CATCH_EXCEPTION();
52386   }
52387
52388 }
52389
52390
52391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
52392   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52393   int arg2 ;
52394   int arg3 ;
52395
52396   arg1 = (std::vector< unsigned int > *)jarg1;
52397   arg2 = (int)jarg2;
52398   arg3 = (int)jarg3;
52399   {
52400     try {
52401       try {
52402         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
52403       }
52404       catch(std::out_of_range &_e) {
52405         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52406         return ;
52407       }
52408       catch(std::invalid_argument &_e) {
52409         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
52410         return ;
52411       }
52412
52413     } CALL_CATCH_EXCEPTION();
52414   }
52415
52416 }
52417
52418
52419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
52420   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52421   int arg2 ;
52422   std::vector< unsigned int > *arg3 = 0 ;
52423
52424   arg1 = (std::vector< unsigned int > *)jarg1;
52425   arg2 = (int)jarg2;
52426   arg3 = (std::vector< unsigned int > *)jarg3;
52427   if (!arg3) {
52428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
52429     return ;
52430   }
52431   {
52432     try {
52433       try {
52434         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
52435       }
52436       catch(std::out_of_range &_e) {
52437         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52438         return ;
52439       }
52440
52441     } CALL_CATCH_EXCEPTION();
52442   }
52443
52444 }
52445
52446
52447 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
52448   unsigned int jresult ;
52449   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52450   unsigned int *arg2 = 0 ;
52451   unsigned int temp2 ;
52452   bool result;
52453
52454   arg1 = (std::vector< unsigned int > *)jarg1;
52455   temp2 = (unsigned int)jarg2;
52456   arg2 = &temp2;
52457   {
52458     try {
52459       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
52460     } CALL_CATCH_EXCEPTION(0);
52461   }
52462
52463   jresult = result;
52464   return jresult;
52465 }
52466
52467
52468 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
52469   int jresult ;
52470   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52471   unsigned int *arg2 = 0 ;
52472   unsigned int temp2 ;
52473   int result;
52474
52475   arg1 = (std::vector< unsigned int > *)jarg1;
52476   temp2 = (unsigned int)jarg2;
52477   arg2 = &temp2;
52478   {
52479     try {
52480       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
52481     } CALL_CATCH_EXCEPTION(0);
52482   }
52483
52484   jresult = result;
52485   return jresult;
52486 }
52487
52488
52489 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
52490   int jresult ;
52491   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52492   unsigned int *arg2 = 0 ;
52493   unsigned int temp2 ;
52494   int result;
52495
52496   arg1 = (std::vector< unsigned int > *)jarg1;
52497   temp2 = (unsigned int)jarg2;
52498   arg2 = &temp2;
52499   {
52500     try {
52501       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
52502     } CALL_CATCH_EXCEPTION(0);
52503   }
52504
52505   jresult = result;
52506   return jresult;
52507 }
52508
52509
52510 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
52511   unsigned int jresult ;
52512   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52513   unsigned int *arg2 = 0 ;
52514   unsigned int temp2 ;
52515   bool result;
52516
52517   arg1 = (std::vector< unsigned int > *)jarg1;
52518   temp2 = (unsigned int)jarg2;
52519   arg2 = &temp2;
52520   {
52521     try {
52522       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
52523     } CALL_CATCH_EXCEPTION(0);
52524   }
52525
52526   jresult = result;
52527   return jresult;
52528 }
52529
52530
52531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
52532   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
52533
52534   arg1 = (std::vector< unsigned int > *)jarg1;
52535   {
52536     try {
52537       delete arg1;
52538     } CALL_CATCH_EXCEPTION();
52539   }
52540
52541 }
52542
52543
52544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
52545   void * jresult ;
52546   std::pair< unsigned int,Dali::Actor > *result = 0 ;
52547
52548   {
52549     try {
52550       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
52551     } CALL_CATCH_EXCEPTION(0);
52552   }
52553
52554   jresult = (void *)result;
52555   return jresult;
52556 }
52557
52558
52559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
52560   void * jresult ;
52561   unsigned int arg1 ;
52562   Dali::Actor arg2 ;
52563   Dali::Actor *argp2 ;
52564   std::pair< unsigned int,Dali::Actor > *result = 0 ;
52565
52566   arg1 = (unsigned int)jarg1;
52567   argp2 = (Dali::Actor *)jarg2;
52568   if (!argp2) {
52569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
52570     return 0;
52571   }
52572   arg2 = *argp2;
52573   {
52574     try {
52575       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
52576     } CALL_CATCH_EXCEPTION(0);
52577   }
52578
52579   jresult = (void *)result;
52580   return jresult;
52581 }
52582
52583
52584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
52585   void * jresult ;
52586   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
52587   std::pair< unsigned int,Dali::Actor > *result = 0 ;
52588
52589   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
52590   if (!arg1) {
52591     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
52592     return 0;
52593   }
52594   {
52595     try {
52596       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
52597     } CALL_CATCH_EXCEPTION(0);
52598   }
52599
52600   jresult = (void *)result;
52601   return jresult;
52602 }
52603
52604
52605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
52606   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
52607   unsigned int arg2 ;
52608
52609   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
52610   arg2 = (unsigned int)jarg2;
52611   if (arg1) (arg1)->first = arg2;
52612 }
52613
52614
52615 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
52616   unsigned int jresult ;
52617   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
52618   unsigned int result;
52619
52620   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
52621   result = (unsigned int) ((arg1)->first);
52622   jresult = result;
52623   return jresult;
52624 }
52625
52626
52627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
52628   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
52629   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
52630
52631   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
52632   arg2 = (Dali::Actor *)jarg2;
52633   if (arg1) (arg1)->second = *arg2;
52634 }
52635
52636
52637 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
52638   void * jresult ;
52639   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
52640   Dali::Actor *result = 0 ;
52641
52642   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
52643   result = (Dali::Actor *)& ((arg1)->second);
52644   jresult = (void *)result;
52645   return jresult;
52646 }
52647
52648
52649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
52650   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
52651
52652   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
52653   {
52654     try {
52655       delete arg1;
52656     } CALL_CATCH_EXCEPTION();
52657   }
52658
52659 }
52660
52661
52662 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
52663   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
52664
52665   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52666   {
52667     try {
52668       (arg1)->clear();
52669     } CALL_CATCH_EXCEPTION();
52670   }
52671
52672 }
52673
52674
52675 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
52676   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
52677   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
52678
52679   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52680   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
52681   if (!arg2) {
52682     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
52683     return ;
52684   }
52685   {
52686     try {
52687       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
52688     } CALL_CATCH_EXCEPTION();
52689   }
52690
52691 }
52692
52693
52694 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
52695   unsigned long jresult ;
52696   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
52697   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
52698
52699   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52700   {
52701     try {
52702       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
52703     } CALL_CATCH_EXCEPTION(0);
52704   }
52705
52706   jresult = (unsigned long)result;
52707   return jresult;
52708 }
52709
52710
52711 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(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)->capacity();
52720     } CALL_CATCH_EXCEPTION(0);
52721   }
52722
52723   jresult = (unsigned long)result;
52724   return jresult;
52725 }
52726
52727
52728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
52729   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
52730   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
52731
52732   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52733   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
52734   {
52735     try {
52736       (arg1)->reserve(arg2);
52737     } CALL_CATCH_EXCEPTION();
52738   }
52739
52740 }
52741
52742
52743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
52744   void * jresult ;
52745   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
52746
52747   {
52748     try {
52749       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
52750     } CALL_CATCH_EXCEPTION(0);
52751   }
52752
52753   jresult = (void *)result;
52754   return jresult;
52755 }
52756
52757
52758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
52759   void * jresult ;
52760   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
52761   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
52762
52763   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52764   if (!arg1) {
52765     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
52766     return 0;
52767   }
52768   {
52769     try {
52770       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);
52771     } CALL_CATCH_EXCEPTION(0);
52772   }
52773
52774   jresult = (void *)result;
52775   return jresult;
52776 }
52777
52778
52779 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
52780   void * jresult ;
52781   int arg1 ;
52782   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
52783
52784   arg1 = (int)jarg1;
52785   {
52786     try {
52787       try {
52788         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);
52789       }
52790       catch(std::out_of_range &_e) {
52791         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52792         return 0;
52793       }
52794
52795     } CALL_CATCH_EXCEPTION(0);
52796   }
52797
52798   jresult = (void *)result;
52799   return jresult;
52800 }
52801
52802
52803 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
52804   void * jresult ;
52805   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
52806   int arg2 ;
52807   std::pair< unsigned int,Dali::Actor > result;
52808
52809   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52810   arg2 = (int)jarg2;
52811   {
52812     try {
52813       try {
52814         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
52815       }
52816       catch(std::out_of_range &_e) {
52817         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52818         return 0;
52819       }
52820
52821     } CALL_CATCH_EXCEPTION(0);
52822   }
52823
52824   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
52825   return jresult;
52826 }
52827
52828
52829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
52830   void * jresult ;
52831   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
52832   int arg2 ;
52833   std::pair< unsigned int,Dali::Actor > *result = 0 ;
52834
52835   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52836   arg2 = (int)jarg2;
52837   {
52838     try {
52839       try {
52840         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
52841       }
52842       catch(std::out_of_range &_e) {
52843         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52844         return 0;
52845       }
52846
52847     } CALL_CATCH_EXCEPTION(0);
52848   }
52849
52850   jresult = (void *)result;
52851   return jresult;
52852 }
52853
52854
52855 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
52856   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
52857   int arg2 ;
52858   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
52859
52860   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52861   arg2 = (int)jarg2;
52862   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
52863   if (!arg3) {
52864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
52865     return ;
52866   }
52867   {
52868     try {
52869       try {
52870         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);
52871       }
52872       catch(std::out_of_range &_e) {
52873         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52874         return ;
52875       }
52876
52877     } CALL_CATCH_EXCEPTION();
52878   }
52879
52880 }
52881
52882
52883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
52884   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
52885   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
52886
52887   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52888   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
52889   if (!arg2) {
52890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
52891     return ;
52892   }
52893   {
52894     try {
52895       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);
52896     } CALL_CATCH_EXCEPTION();
52897   }
52898
52899 }
52900
52901
52902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
52903   void * jresult ;
52904   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
52905   int arg2 ;
52906   int arg3 ;
52907   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
52908
52909   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52910   arg2 = (int)jarg2;
52911   arg3 = (int)jarg3;
52912   {
52913     try {
52914       try {
52915         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);
52916       }
52917       catch(std::out_of_range &_e) {
52918         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52919         return 0;
52920       }
52921       catch(std::invalid_argument &_e) {
52922         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
52923         return 0;
52924       }
52925
52926     } CALL_CATCH_EXCEPTION(0);
52927   }
52928
52929   jresult = (void *)result;
52930   return jresult;
52931 }
52932
52933
52934 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
52935   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
52936   int arg2 ;
52937   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
52938
52939   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52940   arg2 = (int)jarg2;
52941   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
52942   if (!arg3) {
52943     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
52944     return ;
52945   }
52946   {
52947     try {
52948       try {
52949         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);
52950       }
52951       catch(std::out_of_range &_e) {
52952         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52953         return ;
52954       }
52955
52956     } CALL_CATCH_EXCEPTION();
52957   }
52958
52959 }
52960
52961
52962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
52963   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
52964   int arg2 ;
52965   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
52966
52967   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52968   arg2 = (int)jarg2;
52969   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
52970   if (!arg3) {
52971     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
52972     return ;
52973   }
52974   {
52975     try {
52976       try {
52977         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);
52978       }
52979       catch(std::out_of_range &_e) {
52980         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
52981         return ;
52982       }
52983
52984     } CALL_CATCH_EXCEPTION();
52985   }
52986
52987 }
52988
52989
52990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
52991   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
52992   int arg2 ;
52993
52994   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
52995   arg2 = (int)jarg2;
52996   {
52997     try {
52998       try {
52999         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
53000       }
53001       catch(std::out_of_range &_e) {
53002         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53003         return ;
53004       }
53005
53006     } CALL_CATCH_EXCEPTION();
53007   }
53008
53009 }
53010
53011
53012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
53013   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
53014   int arg2 ;
53015   int arg3 ;
53016
53017   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
53018   arg2 = (int)jarg2;
53019   arg3 = (int)jarg3;
53020   {
53021     try {
53022       try {
53023         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
53024       }
53025       catch(std::out_of_range &_e) {
53026         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53027         return ;
53028       }
53029       catch(std::invalid_argument &_e) {
53030         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
53031         return ;
53032       }
53033
53034     } CALL_CATCH_EXCEPTION();
53035   }
53036
53037 }
53038
53039
53040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
53041   void * jresult ;
53042   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
53043   int arg2 ;
53044   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
53045
53046   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
53047   if (!arg1) {
53048     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
53049     return 0;
53050   }
53051   arg2 = (int)jarg2;
53052   {
53053     try {
53054       try {
53055         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);
53056       }
53057       catch(std::out_of_range &_e) {
53058         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53059         return 0;
53060       }
53061
53062     } CALL_CATCH_EXCEPTION(0);
53063   }
53064
53065   jresult = (void *)result;
53066   return jresult;
53067 }
53068
53069
53070 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
53071   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
53072
53073   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
53074   {
53075     try {
53076       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
53077     } CALL_CATCH_EXCEPTION();
53078   }
53079
53080 }
53081
53082
53083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
53084   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
53085   int arg2 ;
53086   int arg3 ;
53087
53088   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
53089   arg2 = (int)jarg2;
53090   arg3 = (int)jarg3;
53091   {
53092     try {
53093       try {
53094         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
53095       }
53096       catch(std::out_of_range &_e) {
53097         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53098         return ;
53099       }
53100       catch(std::invalid_argument &_e) {
53101         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
53102         return ;
53103       }
53104
53105     } CALL_CATCH_EXCEPTION();
53106   }
53107
53108 }
53109
53110
53111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
53112   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
53113   int arg2 ;
53114   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
53115
53116   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
53117   arg2 = (int)jarg2;
53118   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
53119   if (!arg3) {
53120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
53121     return ;
53122   }
53123   {
53124     try {
53125       try {
53126         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);
53127       }
53128       catch(std::out_of_range &_e) {
53129         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53130         return ;
53131       }
53132
53133     } CALL_CATCH_EXCEPTION();
53134   }
53135
53136 }
53137
53138
53139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
53140   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
53141
53142   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
53143   {
53144     try {
53145       delete arg1;
53146     } CALL_CATCH_EXCEPTION();
53147   }
53148
53149 }
53150
53151
53152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
53153   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53154
53155   arg1 = (std::vector< Dali::Actor > *)jarg1;
53156   {
53157     try {
53158       (arg1)->clear();
53159     } CALL_CATCH_EXCEPTION();
53160   }
53161
53162 }
53163
53164
53165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
53166   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53167   Dali::Actor *arg2 = 0 ;
53168
53169   arg1 = (std::vector< Dali::Actor > *)jarg1;
53170   arg2 = (Dali::Actor *)jarg2;
53171   if (!arg2) {
53172     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
53173     return ;
53174   }
53175   {
53176     try {
53177       (arg1)->push_back((Dali::Actor const &)*arg2);
53178     } CALL_CATCH_EXCEPTION();
53179   }
53180
53181 }
53182
53183
53184 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
53185   unsigned long jresult ;
53186   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53187   std::vector< Dali::Actor >::size_type result;
53188
53189   arg1 = (std::vector< Dali::Actor > *)jarg1;
53190   {
53191     try {
53192       result = ((std::vector< Dali::Actor > const *)arg1)->size();
53193     } CALL_CATCH_EXCEPTION(0);
53194   }
53195
53196   jresult = (unsigned long)result;
53197   return jresult;
53198 }
53199
53200
53201 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(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)->capacity();
53210     } CALL_CATCH_EXCEPTION(0);
53211   }
53212
53213   jresult = (unsigned long)result;
53214   return jresult;
53215 }
53216
53217
53218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
53219   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53220   std::vector< Dali::Actor >::size_type arg2 ;
53221
53222   arg1 = (std::vector< Dali::Actor > *)jarg1;
53223   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
53224   {
53225     try {
53226       (arg1)->reserve(arg2);
53227     } CALL_CATCH_EXCEPTION();
53228   }
53229
53230 }
53231
53232
53233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
53234   void * jresult ;
53235   std::vector< Dali::Actor > *result = 0 ;
53236
53237   {
53238     try {
53239       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
53240     } CALL_CATCH_EXCEPTION(0);
53241   }
53242
53243   jresult = (void *)result;
53244   return jresult;
53245 }
53246
53247
53248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
53249   void * jresult ;
53250   std::vector< Dali::Actor > *arg1 = 0 ;
53251   std::vector< Dali::Actor > *result = 0 ;
53252
53253   arg1 = (std::vector< Dali::Actor > *)jarg1;
53254   if (!arg1) {
53255     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
53256     return 0;
53257   }
53258   {
53259     try {
53260       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
53261     } CALL_CATCH_EXCEPTION(0);
53262   }
53263
53264   jresult = (void *)result;
53265   return jresult;
53266 }
53267
53268
53269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
53270   void * jresult ;
53271   int arg1 ;
53272   std::vector< Dali::Actor > *result = 0 ;
53273
53274   arg1 = (int)jarg1;
53275   {
53276     try {
53277       try {
53278         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
53279       }
53280       catch(std::out_of_range &_e) {
53281         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53282         return 0;
53283       }
53284
53285     } CALL_CATCH_EXCEPTION(0);
53286   }
53287
53288   jresult = (void *)result;
53289   return jresult;
53290 }
53291
53292
53293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
53294   void * jresult ;
53295   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53296   int arg2 ;
53297   Dali::Actor result;
53298
53299   arg1 = (std::vector< Dali::Actor > *)jarg1;
53300   arg2 = (int)jarg2;
53301   {
53302     try {
53303       try {
53304         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
53305       }
53306       catch(std::out_of_range &_e) {
53307         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53308         return 0;
53309       }
53310
53311     } CALL_CATCH_EXCEPTION(0);
53312   }
53313
53314   jresult = new Dali::Actor((const Dali::Actor &)result);
53315   return jresult;
53316 }
53317
53318
53319 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
53320   void * jresult ;
53321   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53322   int arg2 ;
53323   Dali::Actor *result = 0 ;
53324
53325   arg1 = (std::vector< Dali::Actor > *)jarg1;
53326   arg2 = (int)jarg2;
53327   {
53328     try {
53329       try {
53330         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
53331       }
53332       catch(std::out_of_range &_e) {
53333         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53334         return 0;
53335       }
53336
53337     } CALL_CATCH_EXCEPTION(0);
53338   }
53339
53340   jresult = (void *)result;
53341   return jresult;
53342 }
53343
53344
53345 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
53346   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53347   int arg2 ;
53348   Dali::Actor *arg3 = 0 ;
53349
53350   arg1 = (std::vector< Dali::Actor > *)jarg1;
53351   arg2 = (int)jarg2;
53352   arg3 = (Dali::Actor *)jarg3;
53353   if (!arg3) {
53354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
53355     return ;
53356   }
53357   {
53358     try {
53359       try {
53360         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
53361       }
53362       catch(std::out_of_range &_e) {
53363         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53364         return ;
53365       }
53366
53367     } CALL_CATCH_EXCEPTION();
53368   }
53369
53370 }
53371
53372
53373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
53374   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53375   std::vector< Dali::Actor > *arg2 = 0 ;
53376
53377   arg1 = (std::vector< Dali::Actor > *)jarg1;
53378   arg2 = (std::vector< Dali::Actor > *)jarg2;
53379   if (!arg2) {
53380     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
53381     return ;
53382   }
53383   {
53384     try {
53385       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
53386     } CALL_CATCH_EXCEPTION();
53387   }
53388
53389 }
53390
53391
53392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
53393   void * jresult ;
53394   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53395   int arg2 ;
53396   int arg3 ;
53397   std::vector< Dali::Actor > *result = 0 ;
53398
53399   arg1 = (std::vector< Dali::Actor > *)jarg1;
53400   arg2 = (int)jarg2;
53401   arg3 = (int)jarg3;
53402   {
53403     try {
53404       try {
53405         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
53406       }
53407       catch(std::out_of_range &_e) {
53408         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53409         return 0;
53410       }
53411       catch(std::invalid_argument &_e) {
53412         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
53413         return 0;
53414       }
53415
53416     } CALL_CATCH_EXCEPTION(0);
53417   }
53418
53419   jresult = (void *)result;
53420   return jresult;
53421 }
53422
53423
53424 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
53425   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53426   int arg2 ;
53427   Dali::Actor *arg3 = 0 ;
53428
53429   arg1 = (std::vector< Dali::Actor > *)jarg1;
53430   arg2 = (int)jarg2;
53431   arg3 = (Dali::Actor *)jarg3;
53432   if (!arg3) {
53433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
53434     return ;
53435   }
53436   {
53437     try {
53438       try {
53439         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
53440       }
53441       catch(std::out_of_range &_e) {
53442         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53443         return ;
53444       }
53445
53446     } CALL_CATCH_EXCEPTION();
53447   }
53448
53449 }
53450
53451
53452 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
53453   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53454   int arg2 ;
53455   std::vector< Dali::Actor > *arg3 = 0 ;
53456
53457   arg1 = (std::vector< Dali::Actor > *)jarg1;
53458   arg2 = (int)jarg2;
53459   arg3 = (std::vector< Dali::Actor > *)jarg3;
53460   if (!arg3) {
53461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
53462     return ;
53463   }
53464   {
53465     try {
53466       try {
53467         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
53468       }
53469       catch(std::out_of_range &_e) {
53470         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53471         return ;
53472       }
53473
53474     } CALL_CATCH_EXCEPTION();
53475   }
53476
53477 }
53478
53479
53480 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
53481   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53482   int arg2 ;
53483
53484   arg1 = (std::vector< Dali::Actor > *)jarg1;
53485   arg2 = (int)jarg2;
53486   {
53487     try {
53488       try {
53489         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
53490       }
53491       catch(std::out_of_range &_e) {
53492         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53493         return ;
53494       }
53495
53496     } CALL_CATCH_EXCEPTION();
53497   }
53498
53499 }
53500
53501
53502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
53503   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53504   int arg2 ;
53505   int arg3 ;
53506
53507   arg1 = (std::vector< Dali::Actor > *)jarg1;
53508   arg2 = (int)jarg2;
53509   arg3 = (int)jarg3;
53510   {
53511     try {
53512       try {
53513         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
53514       }
53515       catch(std::out_of_range &_e) {
53516         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53517         return ;
53518       }
53519       catch(std::invalid_argument &_e) {
53520         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
53521         return ;
53522       }
53523
53524     } CALL_CATCH_EXCEPTION();
53525   }
53526
53527 }
53528
53529
53530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
53531   void * jresult ;
53532   Dali::Actor *arg1 = 0 ;
53533   int arg2 ;
53534   std::vector< Dali::Actor > *result = 0 ;
53535
53536   arg1 = (Dali::Actor *)jarg1;
53537   if (!arg1) {
53538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
53539     return 0;
53540   }
53541   arg2 = (int)jarg2;
53542   {
53543     try {
53544       try {
53545         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
53546       }
53547       catch(std::out_of_range &_e) {
53548         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53549         return 0;
53550       }
53551
53552     } CALL_CATCH_EXCEPTION(0);
53553   }
53554
53555   jresult = (void *)result;
53556   return jresult;
53557 }
53558
53559
53560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
53561   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53562
53563   arg1 = (std::vector< Dali::Actor > *)jarg1;
53564   {
53565     try {
53566       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
53567     } CALL_CATCH_EXCEPTION();
53568   }
53569
53570 }
53571
53572
53573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
53574   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53575   int arg2 ;
53576   int arg3 ;
53577
53578   arg1 = (std::vector< Dali::Actor > *)jarg1;
53579   arg2 = (int)jarg2;
53580   arg3 = (int)jarg3;
53581   {
53582     try {
53583       try {
53584         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
53585       }
53586       catch(std::out_of_range &_e) {
53587         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53588         return ;
53589       }
53590       catch(std::invalid_argument &_e) {
53591         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
53592         return ;
53593       }
53594
53595     } CALL_CATCH_EXCEPTION();
53596   }
53597
53598 }
53599
53600
53601 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
53602   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53603   int arg2 ;
53604   std::vector< Dali::Actor > *arg3 = 0 ;
53605
53606   arg1 = (std::vector< Dali::Actor > *)jarg1;
53607   arg2 = (int)jarg2;
53608   arg3 = (std::vector< Dali::Actor > *)jarg3;
53609   if (!arg3) {
53610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
53611     return ;
53612   }
53613   {
53614     try {
53615       try {
53616         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
53617       }
53618       catch(std::out_of_range &_e) {
53619         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
53620         return ;
53621       }
53622
53623     } CALL_CATCH_EXCEPTION();
53624   }
53625
53626 }
53627
53628
53629 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
53630   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
53631
53632   arg1 = (std::vector< Dali::Actor > *)jarg1;
53633   {
53634     try {
53635       delete arg1;
53636     } CALL_CATCH_EXCEPTION();
53637   }
53638
53639 }
53640
53641
53642 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
53643   unsigned int jresult ;
53644   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
53645   bool result;
53646
53647   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
53648   {
53649     try {
53650       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
53651     } CALL_CATCH_EXCEPTION(0);
53652   }
53653
53654   jresult = result;
53655   return jresult;
53656 }
53657
53658
53659 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
53660   unsigned long jresult ;
53661   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
53662   std::size_t result;
53663
53664   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
53665   {
53666     try {
53667       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
53668     } CALL_CATCH_EXCEPTION(0);
53669   }
53670
53671   jresult = (unsigned long)result;
53672   return jresult;
53673 }
53674
53675
53676 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
53677   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
53678   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
53679
53680   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
53681   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
53682   {
53683     try {
53684       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
53685     } CALL_CATCH_EXCEPTION();
53686   }
53687
53688 }
53689
53690
53691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
53692   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
53693   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
53694
53695   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
53696   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
53697   {
53698     try {
53699       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
53700     } CALL_CATCH_EXCEPTION();
53701   }
53702
53703 }
53704
53705
53706 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
53707   unsigned int jresult ;
53708   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
53709   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
53710   bool result;
53711
53712   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
53713   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
53714   if (!arg2) {
53715     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
53716     return 0;
53717   }
53718   {
53719     try {
53720       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
53721     } CALL_CATCH_EXCEPTION(0);
53722   }
53723
53724   jresult = result;
53725   return jresult;
53726 }
53727
53728
53729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
53730   void * jresult ;
53731   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
53732
53733   {
53734     try {
53735       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
53736     } CALL_CATCH_EXCEPTION(0);
53737   }
53738
53739   jresult = (void *)result;
53740   return jresult;
53741 }
53742
53743
53744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
53745   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
53746
53747   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
53748   {
53749     try {
53750       delete arg1;
53751     } CALL_CATCH_EXCEPTION();
53752   }
53753
53754 }
53755
53756
53757 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
53758   unsigned int jresult ;
53759   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
53760   bool result;
53761
53762   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
53763   {
53764     try {
53765       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);
53766     } CALL_CATCH_EXCEPTION(0);
53767   }
53768
53769   jresult = result;
53770   return jresult;
53771 }
53772
53773
53774 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
53775   unsigned long jresult ;
53776   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
53777   std::size_t result;
53778
53779   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
53780   {
53781     try {
53782       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);
53783     } CALL_CATCH_EXCEPTION(0);
53784   }
53785
53786   jresult = (unsigned long)result;
53787   return jresult;
53788 }
53789
53790
53791 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
53792   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
53793   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
53794
53795   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
53796   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
53797   {
53798     try {
53799       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
53800     } CALL_CATCH_EXCEPTION();
53801   }
53802
53803 }
53804
53805
53806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
53807   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
53808   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
53809
53810   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
53811   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
53812   {
53813     try {
53814       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
53815     } CALL_CATCH_EXCEPTION();
53816   }
53817
53818 }
53819
53820
53821 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
53822   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
53823   Dali::Actor arg2 ;
53824   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
53825   Dali::Actor *argp2 ;
53826
53827   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
53828   argp2 = (Dali::Actor *)jarg2;
53829   if (!argp2) {
53830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
53831     return ;
53832   }
53833   arg2 = *argp2;
53834   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
53835   {
53836     try {
53837       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
53838     } CALL_CATCH_EXCEPTION();
53839   }
53840
53841 }
53842
53843
53844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
53845   void * jresult ;
53846   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
53847
53848   {
53849     try {
53850       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
53851     } CALL_CATCH_EXCEPTION(0);
53852   }
53853
53854   jresult = (void *)result;
53855   return jresult;
53856 }
53857
53858
53859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
53860   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
53861
53862   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
53863   {
53864     try {
53865       delete arg1;
53866     } CALL_CATCH_EXCEPTION();
53867   }
53868
53869 }
53870
53871
53872 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
53873   unsigned int jresult ;
53874   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
53875   bool result;
53876
53877   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
53878   {
53879     try {
53880       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
53881     } CALL_CATCH_EXCEPTION(0);
53882   }
53883
53884   jresult = result;
53885   return jresult;
53886 }
53887
53888
53889 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
53890   unsigned long jresult ;
53891   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
53892   std::size_t result;
53893
53894   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
53895   {
53896     try {
53897       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
53898     } CALL_CATCH_EXCEPTION(0);
53899   }
53900
53901   jresult = (unsigned long)result;
53902   return jresult;
53903 }
53904
53905
53906 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
53907   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
53908   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
53909
53910   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
53911   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
53912   {
53913     try {
53914       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
53915     } CALL_CATCH_EXCEPTION();
53916   }
53917
53918 }
53919
53920
53921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
53922   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
53923   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
53924
53925   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
53926   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
53927   {
53928     try {
53929       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
53930     } CALL_CATCH_EXCEPTION();
53931   }
53932
53933 }
53934
53935
53936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
53937   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
53938   Dali::Actor arg2 ;
53939   Dali::Actor arg3 ;
53940   Dali::Actor *argp2 ;
53941   Dali::Actor *argp3 ;
53942
53943   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
53944   argp2 = (Dali::Actor *)jarg2;
53945   if (!argp2) {
53946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
53947     return ;
53948   }
53949   arg2 = *argp2;
53950   argp3 = (Dali::Actor *)jarg3;
53951   if (!argp3) {
53952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
53953     return ;
53954   }
53955   arg3 = *argp3;
53956   {
53957     try {
53958       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
53959     } CALL_CATCH_EXCEPTION();
53960   }
53961
53962 }
53963
53964
53965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
53966   void * jresult ;
53967   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
53968
53969   {
53970     try {
53971       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
53972     } CALL_CATCH_EXCEPTION(0);
53973   }
53974
53975   jresult = (void *)result;
53976   return jresult;
53977 }
53978
53979
53980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
53981   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
53982
53983   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
53984   {
53985     try {
53986       delete arg1;
53987     } CALL_CATCH_EXCEPTION();
53988   }
53989
53990 }
53991
53992
53993 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
53994   unsigned int jresult ;
53995   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
53996   bool result;
53997
53998   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
53999   {
54000     try {
54001       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
54002     } CALL_CATCH_EXCEPTION(0);
54003   }
54004
54005   jresult = result;
54006   return jresult;
54007 }
54008
54009
54010 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
54011   unsigned long jresult ;
54012   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
54013   std::size_t result;
54014
54015   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
54016   {
54017     try {
54018       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
54019     } CALL_CATCH_EXCEPTION(0);
54020   }
54021
54022   jresult = (unsigned long)result;
54023   return jresult;
54024 }
54025
54026
54027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
54028   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
54029   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
54030
54031   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
54032   arg2 = (void (*)(Dali::Actor,bool))jarg2;
54033   {
54034     try {
54035       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
54036     } CALL_CATCH_EXCEPTION();
54037   }
54038
54039 }
54040
54041
54042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
54043   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
54044   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
54045
54046   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
54047   arg2 = (void (*)(Dali::Actor,bool))jarg2;
54048   {
54049     try {
54050       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
54051     } CALL_CATCH_EXCEPTION();
54052   }
54053
54054 }
54055
54056
54057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
54058   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
54059   Dali::Actor arg2 ;
54060   bool arg3 ;
54061   Dali::Actor *argp2 ;
54062
54063   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
54064   argp2 = (Dali::Actor *)jarg2;
54065   if (!argp2) {
54066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
54067     return ;
54068   }
54069   arg2 = *argp2;
54070   arg3 = jarg3 ? true : false;
54071   {
54072     try {
54073       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
54074     } CALL_CATCH_EXCEPTION();
54075   }
54076
54077 }
54078
54079
54080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
54081   void * jresult ;
54082   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
54083
54084   {
54085     try {
54086       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
54087     } CALL_CATCH_EXCEPTION(0);
54088   }
54089
54090   jresult = (void *)result;
54091   return jresult;
54092 }
54093
54094
54095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
54096   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
54097
54098   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
54099   {
54100     try {
54101       delete arg1;
54102     } CALL_CATCH_EXCEPTION();
54103   }
54104
54105 }
54106
54107
54108 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
54109   unsigned int jresult ;
54110   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
54111   bool result;
54112
54113   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
54114   {
54115     try {
54116       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);
54117     } CALL_CATCH_EXCEPTION(0);
54118   }
54119
54120   jresult = result;
54121   return jresult;
54122 }
54123
54124
54125 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
54126   unsigned long jresult ;
54127   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
54128   std::size_t result;
54129
54130   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
54131   {
54132     try {
54133       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);
54134     } CALL_CATCH_EXCEPTION(0);
54135   }
54136
54137   jresult = (unsigned long)result;
54138   return jresult;
54139 }
54140
54141
54142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
54143   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
54144   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
54145
54146   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
54147   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
54148   {
54149     try {
54150       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
54151     } CALL_CATCH_EXCEPTION();
54152   }
54153
54154 }
54155
54156
54157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
54158   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
54159   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
54160
54161   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
54162   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
54163   {
54164     try {
54165       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
54166     } CALL_CATCH_EXCEPTION();
54167   }
54168
54169 }
54170
54171
54172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
54173   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
54174   Dali::Toolkit::StyleManager arg2 ;
54175   Dali::StyleChange::Type arg3 ;
54176   Dali::Toolkit::StyleManager *argp2 ;
54177
54178   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
54179   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
54180   if (!argp2) {
54181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
54182     return ;
54183   }
54184   arg2 = *argp2;
54185   arg3 = (Dali::StyleChange::Type)jarg3;
54186   {
54187     try {
54188       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
54189     } CALL_CATCH_EXCEPTION();
54190   }
54191
54192 }
54193
54194
54195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
54196   void * jresult ;
54197   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
54198
54199   {
54200     try {
54201       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
54202     } CALL_CATCH_EXCEPTION(0);
54203   }
54204
54205   jresult = (void *)result;
54206   return jresult;
54207 }
54208
54209
54210 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
54211   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
54212
54213   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
54214   {
54215     try {
54216       delete arg1;
54217     } CALL_CATCH_EXCEPTION();
54218   }
54219
54220 }
54221
54222
54223 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
54224   unsigned int jresult ;
54225   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
54226   bool result;
54227
54228   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
54229   {
54230     try {
54231       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
54232     } CALL_CATCH_EXCEPTION(0);
54233   }
54234
54235   jresult = result;
54236   return jresult;
54237 }
54238
54239
54240 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
54241   unsigned long jresult ;
54242   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
54243   std::size_t result;
54244
54245   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
54246   {
54247     try {
54248       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
54249     } CALL_CATCH_EXCEPTION(0);
54250   }
54251
54252   jresult = (unsigned long)result;
54253   return jresult;
54254 }
54255
54256
54257 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
54258   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
54259   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
54260
54261   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
54262   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
54263   {
54264     try {
54265       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
54266     } CALL_CATCH_EXCEPTION();
54267   }
54268
54269 }
54270
54271
54272 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
54273   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
54274   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
54275
54276   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
54277   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
54278   {
54279     try {
54280       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
54281     } CALL_CATCH_EXCEPTION();
54282   }
54283
54284 }
54285
54286
54287 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
54288   unsigned int jresult ;
54289   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
54290   Dali::Toolkit::Button arg2 ;
54291   Dali::Toolkit::Button *argp2 ;
54292   bool result;
54293
54294   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
54295   argp2 = (Dali::Toolkit::Button *)jarg2;
54296   if (!argp2) {
54297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
54298     return 0;
54299   }
54300   arg2 = *argp2;
54301   {
54302     try {
54303       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
54304     } CALL_CATCH_EXCEPTION(0);
54305   }
54306
54307   jresult = result;
54308   return jresult;
54309 }
54310
54311
54312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
54313   void * jresult ;
54314   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
54315
54316   {
54317     try {
54318       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
54319     } CALL_CATCH_EXCEPTION(0);
54320   }
54321
54322   jresult = (void *)result;
54323   return jresult;
54324 }
54325
54326
54327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
54328   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
54329
54330   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
54331   {
54332     try {
54333       delete arg1;
54334     } CALL_CATCH_EXCEPTION();
54335   }
54336
54337 }
54338
54339
54340 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
54341   unsigned int jresult ;
54342   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
54343   bool result;
54344
54345   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
54346   {
54347     try {
54348       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
54349     } CALL_CATCH_EXCEPTION(0);
54350   }
54351
54352   jresult = result;
54353   return jresult;
54354 }
54355
54356
54357 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
54358   unsigned long jresult ;
54359   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
54360   std::size_t result;
54361
54362   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
54363   {
54364     try {
54365       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
54366     } CALL_CATCH_EXCEPTION(0);
54367   }
54368
54369   jresult = (unsigned long)result;
54370   return jresult;
54371 }
54372
54373
54374 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
54375   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
54376   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
54377
54378   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
54379   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
54380   {
54381     try {
54382       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
54383     } CALL_CATCH_EXCEPTION();
54384   }
54385
54386 }
54387
54388
54389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
54390   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
54391   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
54392
54393   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
54394   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
54395   {
54396     try {
54397       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
54398     } CALL_CATCH_EXCEPTION();
54399   }
54400
54401 }
54402
54403
54404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
54405   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
54406   Dali::Toolkit::GaussianBlurView arg2 ;
54407   Dali::Toolkit::GaussianBlurView *argp2 ;
54408
54409   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
54410   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
54411   if (!argp2) {
54412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
54413     return ;
54414   }
54415   arg2 = *argp2;
54416   {
54417     try {
54418       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
54419     } CALL_CATCH_EXCEPTION();
54420   }
54421
54422 }
54423
54424
54425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
54426   void * jresult ;
54427   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
54428
54429   {
54430     try {
54431       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
54432     } CALL_CATCH_EXCEPTION(0);
54433   }
54434
54435   jresult = (void *)result;
54436   return jresult;
54437 }
54438
54439
54440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
54441   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
54442
54443   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
54444   {
54445     try {
54446       delete arg1;
54447     } CALL_CATCH_EXCEPTION();
54448   }
54449
54450 }
54451
54452
54453 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
54454   unsigned int jresult ;
54455   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
54456   bool result;
54457
54458   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
54459   {
54460     try {
54461       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);
54462     } CALL_CATCH_EXCEPTION(0);
54463   }
54464
54465   jresult = result;
54466   return jresult;
54467 }
54468
54469
54470 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
54471   unsigned long jresult ;
54472   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
54473   std::size_t result;
54474
54475   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
54476   {
54477     try {
54478       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);
54479     } CALL_CATCH_EXCEPTION(0);
54480   }
54481
54482   jresult = (unsigned long)result;
54483   return jresult;
54484 }
54485
54486
54487 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
54488   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
54489   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
54490
54491   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
54492   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
54493   {
54494     try {
54495       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
54496     } CALL_CATCH_EXCEPTION();
54497   }
54498
54499 }
54500
54501
54502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
54503   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
54504   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
54505
54506   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
54507   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
54508   {
54509     try {
54510       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
54511     } CALL_CATCH_EXCEPTION();
54512   }
54513
54514 }
54515
54516
54517 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
54518   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
54519   Dali::Toolkit::PageTurnView arg2 ;
54520   unsigned int arg3 ;
54521   bool arg4 ;
54522   Dali::Toolkit::PageTurnView *argp2 ;
54523
54524   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
54525   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
54526   if (!argp2) {
54527     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
54528     return ;
54529   }
54530   arg2 = *argp2;
54531   arg3 = (unsigned int)jarg3;
54532   arg4 = jarg4 ? true : false;
54533   {
54534     try {
54535       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
54536     } CALL_CATCH_EXCEPTION();
54537   }
54538
54539 }
54540
54541
54542 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
54543   void * jresult ;
54544   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
54545
54546   {
54547     try {
54548       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
54549     } CALL_CATCH_EXCEPTION(0);
54550   }
54551
54552   jresult = (void *)result;
54553   return jresult;
54554 }
54555
54556
54557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
54558   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
54559
54560   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
54561   {
54562     try {
54563       delete arg1;
54564     } CALL_CATCH_EXCEPTION();
54565   }
54566
54567 }
54568
54569
54570 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
54571   unsigned int jresult ;
54572   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
54573   bool result;
54574
54575   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
54576   {
54577     try {
54578       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
54579     } CALL_CATCH_EXCEPTION(0);
54580   }
54581
54582   jresult = result;
54583   return jresult;
54584 }
54585
54586
54587 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
54588   unsigned long jresult ;
54589   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
54590   std::size_t result;
54591
54592   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
54593   {
54594     try {
54595       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
54596     } CALL_CATCH_EXCEPTION(0);
54597   }
54598
54599   jresult = (unsigned long)result;
54600   return jresult;
54601 }
54602
54603
54604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
54605   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
54606   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
54607
54608   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
54609   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
54610   {
54611     try {
54612       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
54613     } CALL_CATCH_EXCEPTION();
54614   }
54615 }
54616
54617
54618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
54619   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
54620   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
54621
54622   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
54623   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
54624   {
54625     try {
54626       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
54627     } CALL_CATCH_EXCEPTION();
54628   }
54629 }
54630
54631
54632 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
54633   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
54634   Dali::Toolkit::PageTurnView arg2 ;
54635   Dali::Toolkit::PageTurnView *argp2 ;
54636
54637   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
54638   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
54639   if (!argp2) {
54640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
54641     return ;
54642   }
54643   arg2 = *argp2;
54644   {
54645     try {
54646       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
54647     } CALL_CATCH_EXCEPTION();
54648   }
54649 }
54650
54651
54652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
54653   void * jresult ;
54654   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
54655
54656   {
54657     try {
54658       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
54659     } CALL_CATCH_EXCEPTION(0);
54660   }
54661
54662   jresult = (void *)result;
54663   return jresult;
54664 }
54665
54666
54667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
54668   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
54669
54670   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
54671   {
54672     try {
54673       delete arg1;
54674     } CALL_CATCH_EXCEPTION();
54675   }
54676
54677 }
54678
54679
54680 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
54681   unsigned int jresult ;
54682   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
54683   bool result;
54684
54685   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
54686   {
54687     try {
54688       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);
54689     } CALL_CATCH_EXCEPTION(0);
54690   }
54691
54692   jresult = result;
54693   return jresult;
54694 }
54695
54696
54697 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
54698   unsigned long jresult ;
54699   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
54700   std::size_t result;
54701
54702   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
54703   {
54704     try {
54705       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);
54706     } CALL_CATCH_EXCEPTION(0);
54707   }
54708
54709   jresult = (unsigned long)result;
54710   return jresult;
54711 }
54712
54713
54714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
54715   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
54716   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
54717
54718   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
54719   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
54720   {
54721     try {
54722       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
54723     } CALL_CATCH_EXCEPTION();
54724   }
54725
54726 }
54727
54728
54729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
54730   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
54731   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
54732
54733   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
54734   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
54735   {
54736     try {
54737       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
54738     } CALL_CATCH_EXCEPTION();
54739   }
54740
54741 }
54742
54743
54744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
54745   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
54746   Dali::Toolkit::ProgressBar arg2 ;
54747   float arg3 ;
54748   float arg4 ;
54749   Dali::Toolkit::ProgressBar *argp2 ;
54750
54751   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
54752   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
54753   if (!argp2) {
54754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
54755     return ;
54756   }
54757   arg2 = *argp2;
54758   arg3 = (float)jarg3;
54759   arg4 = (float)jarg4;
54760   {
54761     try {
54762       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
54763     } CALL_CATCH_EXCEPTION();
54764   }
54765
54766 }
54767
54768
54769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
54770   void * jresult ;
54771   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
54772
54773   {
54774     try {
54775       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
54776     } CALL_CATCH_EXCEPTION(0);
54777   }
54778
54779   jresult = (void *)result;
54780   return jresult;
54781 }
54782
54783
54784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
54785   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
54786
54787   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
54788   {
54789     try {
54790       delete arg1;
54791     } CALL_CATCH_EXCEPTION();
54792   }
54793
54794 }
54795
54796
54797 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
54798   unsigned int jresult ;
54799   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
54800   bool result;
54801
54802   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
54803   {
54804     try {
54805       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);
54806     } CALL_CATCH_EXCEPTION(0);
54807   }
54808
54809   jresult = result;
54810   return jresult;
54811 }
54812
54813
54814 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
54815   unsigned long jresult ;
54816   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
54817   std::size_t result;
54818
54819   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
54820   {
54821     try {
54822       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);
54823     } CALL_CATCH_EXCEPTION(0);
54824   }
54825
54826   jresult = (unsigned long)result;
54827   return jresult;
54828 }
54829
54830
54831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
54832   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
54833   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
54834
54835   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
54836   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
54837   {
54838     try {
54839       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
54840     } CALL_CATCH_EXCEPTION();
54841   }
54842
54843 }
54844
54845
54846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
54847   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
54848   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
54849
54850   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
54851   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
54852   {
54853     try {
54854       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
54855     } CALL_CATCH_EXCEPTION();
54856   }
54857
54858 }
54859
54860
54861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
54862   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
54863   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
54864
54865   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
54866   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
54867   if (!arg2) {
54868     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
54869     return ;
54870   }
54871   {
54872     try {
54873       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
54874     } CALL_CATCH_EXCEPTION();
54875   }
54876
54877 }
54878
54879
54880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
54881   void * jresult ;
54882   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
54883
54884   {
54885     try {
54886       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
54887     } CALL_CATCH_EXCEPTION(0);
54888   }
54889
54890   jresult = (void *)result;
54891   return jresult;
54892 }
54893
54894
54895 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
54896   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
54897
54898   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
54899   {
54900     try {
54901       delete arg1;
54902     } CALL_CATCH_EXCEPTION();
54903   }
54904
54905 }
54906
54907
54908 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
54909   unsigned int jresult ;
54910   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
54911   bool result;
54912
54913   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
54914   {
54915     try {
54916       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
54917     } CALL_CATCH_EXCEPTION(0);
54918   }
54919
54920   jresult = result;
54921   return jresult;
54922 }
54923
54924
54925 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
54926   unsigned long jresult ;
54927   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
54928   std::size_t result;
54929
54930   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
54931   {
54932     try {
54933       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
54934     } CALL_CATCH_EXCEPTION(0);
54935   }
54936
54937   jresult = (unsigned long)result;
54938   return jresult;
54939 }
54940
54941
54942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
54943   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
54944   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
54945
54946   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
54947   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
54948   {
54949     try {
54950       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
54951     } CALL_CATCH_EXCEPTION();
54952   }
54953
54954 }
54955
54956
54957 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
54958   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
54959   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
54960
54961   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
54962   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
54963   {
54964     try {
54965       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
54966     } CALL_CATCH_EXCEPTION();
54967   }
54968
54969 }
54970
54971
54972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
54973   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
54974   Dali::Vector2 *arg2 = 0 ;
54975
54976   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
54977   arg2 = (Dali::Vector2 *)jarg2;
54978   if (!arg2) {
54979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
54980     return ;
54981   }
54982   {
54983     try {
54984       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
54985     } CALL_CATCH_EXCEPTION();
54986   }
54987
54988 }
54989
54990
54991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
54992   void * jresult ;
54993   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
54994
54995   {
54996     try {
54997       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
54998     } CALL_CATCH_EXCEPTION(0);
54999   }
55000
55001   jresult = (void *)result;
55002   return jresult;
55003 }
55004
55005
55006 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
55007   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
55008
55009   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
55010   {
55011     try {
55012       delete arg1;
55013     } CALL_CATCH_EXCEPTION();
55014   }
55015
55016 }
55017
55018
55019
55020 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
55021   unsigned int jresult ;
55022   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
55023   bool result;
55024
55025   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
55026   {
55027     try {
55028       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);
55029     } CALL_CATCH_EXCEPTION(0);
55030   }
55031
55032   jresult = result;
55033   return jresult;
55034 }
55035
55036
55037 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
55038   unsigned long jresult ;
55039   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
55040   std::size_t result;
55041
55042   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
55043   {
55044     try {
55045       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);
55046     } CALL_CATCH_EXCEPTION(0);
55047   }
55048
55049   jresult = (unsigned long)result;
55050   return jresult;
55051 }
55052
55053
55054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
55055   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
55056   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
55057
55058   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
55059   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
55060   {
55061     try {
55062       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55063     } CALL_CATCH_EXCEPTION();
55064   }
55065
55066 }
55067
55068
55069 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
55070   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
55071   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
55072
55073   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
55074   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
55075   {
55076     try {
55077       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55078     } CALL_CATCH_EXCEPTION();
55079   }
55080
55081 }
55082
55083
55084 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55085   unsigned int jresult ;
55086   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
55087   Dali::Toolkit::Control arg2 ;
55088   Dali::KeyEvent *arg3 = 0 ;
55089   Dali::Toolkit::Control *argp2 ;
55090   bool result;
55091
55092   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
55093   argp2 = (Dali::Toolkit::Control *)jarg2;
55094   if (!argp2) {
55095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
55096     return 0;
55097   }
55098   arg2 = *argp2;
55099   arg3 = (Dali::KeyEvent *)jarg3;
55100   if (!arg3) {
55101     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
55102     return 0;
55103   }
55104   {
55105     try {
55106       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);
55107     } CALL_CATCH_EXCEPTION(0);
55108   }
55109
55110   jresult = result;
55111   return jresult;
55112 }
55113
55114
55115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
55116   void * jresult ;
55117   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
55118
55119   {
55120     try {
55121       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
55122     } CALL_CATCH_EXCEPTION(0);
55123   }
55124
55125   jresult = (void *)result;
55126   return jresult;
55127 }
55128
55129
55130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
55131   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
55132
55133   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
55134   {
55135     try {
55136       delete arg1;
55137     } CALL_CATCH_EXCEPTION();
55138   }
55139
55140 }
55141
55142
55143 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
55144   unsigned int jresult ;
55145   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
55146   bool result;
55147
55148   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
55149   {
55150     try {
55151       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
55152     } CALL_CATCH_EXCEPTION(0);
55153   }
55154
55155   jresult = result;
55156   return jresult;
55157 }
55158
55159
55160 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
55161   unsigned long jresult ;
55162   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
55163   std::size_t result;
55164
55165   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
55166   {
55167     try {
55168       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
55169     } CALL_CATCH_EXCEPTION(0);
55170   }
55171
55172   jresult = (unsigned long)result;
55173   return jresult;
55174 }
55175
55176
55177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
55178   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
55179   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
55180
55181   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
55182   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
55183   {
55184     try {
55185       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
55186     } CALL_CATCH_EXCEPTION();
55187   }
55188
55189 }
55190
55191
55192 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
55193   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
55194   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
55195
55196   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
55197   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
55198   {
55199     try {
55200       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
55201     } CALL_CATCH_EXCEPTION();
55202   }
55203
55204 }
55205
55206
55207 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
55208   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
55209   Dali::Toolkit::Control arg2 ;
55210   Dali::Toolkit::Control *argp2 ;
55211
55212   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
55213   argp2 = (Dali::Toolkit::Control *)jarg2;
55214   if (!argp2) {
55215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
55216     return ;
55217   }
55218   arg2 = *argp2;
55219   {
55220     try {
55221       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
55222     } CALL_CATCH_EXCEPTION();
55223   }
55224
55225 }
55226
55227
55228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
55229   void * jresult ;
55230   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
55231
55232   {
55233     try {
55234       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
55235     } CALL_CATCH_EXCEPTION(0);
55236   }
55237
55238   jresult = (void *)result;
55239   return jresult;
55240 }
55241
55242
55243 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
55244   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
55245
55246   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
55247   {
55248     try {
55249       delete arg1;
55250     } CALL_CATCH_EXCEPTION();
55251   }
55252
55253 }
55254
55255
55256 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
55257   unsigned int jresult ;
55258   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
55259   bool result;
55260
55261   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
55262   {
55263     try {
55264       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
55265     } CALL_CATCH_EXCEPTION(0);
55266   }
55267
55268   jresult = result;
55269   return jresult;
55270 }
55271
55272
55273 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
55274   unsigned long jresult ;
55275   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
55276   std::size_t result;
55277
55278   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
55279   {
55280     try {
55281       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
55282     } CALL_CATCH_EXCEPTION(0);
55283   }
55284
55285   jresult = (unsigned long)result;
55286   return jresult;
55287 }
55288
55289
55290 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
55291   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
55292   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
55293
55294   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
55295   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
55296   {
55297     try {
55298       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
55299     } CALL_CATCH_EXCEPTION();
55300   }
55301
55302 }
55303
55304
55305 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
55306   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
55307   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
55308
55309   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
55310   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
55311   {
55312     try {
55313       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
55314     } CALL_CATCH_EXCEPTION();
55315   }
55316
55317 }
55318
55319
55320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
55321   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
55322   Dali::Toolkit::VideoView *arg2 = 0 ;
55323
55324   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
55325   arg2 = (Dali::Toolkit::VideoView *)jarg2;
55326   if (!arg2) {
55327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
55328     return ;
55329   }
55330   {
55331     try {
55332       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
55333     } CALL_CATCH_EXCEPTION();
55334   }
55335
55336 }
55337
55338
55339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
55340   void * jresult ;
55341   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
55342
55343   {
55344     try {
55345       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
55346     } CALL_CATCH_EXCEPTION(0);
55347   }
55348
55349   jresult = (void *)result;
55350   return jresult;
55351 }
55352
55353
55354 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
55355   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
55356
55357   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
55358   {
55359     try {
55360       delete arg1;
55361     } CALL_CATCH_EXCEPTION();
55362   }
55363
55364 }
55365
55366
55367 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
55368   unsigned int jresult ;
55369   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
55370   bool result;
55371
55372   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
55373   {
55374     try {
55375       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
55376     } CALL_CATCH_EXCEPTION(0);
55377   }
55378
55379   jresult = result;
55380   return jresult;
55381 }
55382
55383
55384 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
55385   unsigned long jresult ;
55386   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
55387   std::size_t result;
55388
55389   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
55390   {
55391     try {
55392       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
55393     } CALL_CATCH_EXCEPTION(0);
55394   }
55395
55396   jresult = (unsigned long)result;
55397   return jresult;
55398 }
55399
55400
55401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
55402   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
55403   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
55404
55405   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
55406   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
55407   {
55408     try {
55409       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
55410     } CALL_CATCH_EXCEPTION();
55411   }
55412
55413 }
55414
55415
55416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
55417   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
55418   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
55419
55420   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
55421   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
55422   {
55423     try {
55424       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
55425     } CALL_CATCH_EXCEPTION();
55426   }
55427
55428 }
55429
55430
55431 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
55432   unsigned int jresult ;
55433   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
55434   Dali::Toolkit::Slider arg2 ;
55435   float arg3 ;
55436   Dali::Toolkit::Slider *argp2 ;
55437   bool result;
55438
55439   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
55440   argp2 = (Dali::Toolkit::Slider *)jarg2;
55441   if (!argp2) {
55442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
55443     return 0;
55444   }
55445   arg2 = *argp2;
55446   arg3 = (float)jarg3;
55447   {
55448     try {
55449       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
55450     } CALL_CATCH_EXCEPTION(0);
55451   }
55452
55453   jresult = result;
55454   return jresult;
55455 }
55456
55457
55458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
55459   void * jresult ;
55460   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
55461
55462   {
55463     try {
55464       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
55465     } CALL_CATCH_EXCEPTION(0);
55466   }
55467
55468   jresult = (void *)result;
55469   return jresult;
55470 }
55471
55472
55473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
55474   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
55475
55476   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
55477   {
55478     try {
55479       delete arg1;
55480     } CALL_CATCH_EXCEPTION();
55481   }
55482
55483 }
55484
55485
55486 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
55487   unsigned int jresult ;
55488   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
55489   bool result;
55490
55491   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
55492   {
55493     try {
55494       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
55495     } CALL_CATCH_EXCEPTION(0);
55496   }
55497
55498   jresult = result;
55499   return jresult;
55500 }
55501
55502
55503 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
55504   unsigned long jresult ;
55505   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
55506   std::size_t result;
55507
55508   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
55509   {
55510     try {
55511       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
55512     } CALL_CATCH_EXCEPTION(0);
55513   }
55514
55515   jresult = (unsigned long)result;
55516   return jresult;
55517 }
55518
55519
55520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
55521   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
55522   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
55523
55524   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
55525   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
55526   {
55527     try {
55528       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
55529     } CALL_CATCH_EXCEPTION();
55530   }
55531
55532 }
55533
55534
55535 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
55536   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
55537   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
55538
55539   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
55540   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
55541   {
55542     try {
55543       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
55544     } CALL_CATCH_EXCEPTION();
55545   }
55546
55547 }
55548
55549
55550 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
55551   unsigned int jresult ;
55552   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
55553   Dali::Toolkit::Slider arg2 ;
55554   int arg3 ;
55555   Dali::Toolkit::Slider *argp2 ;
55556   bool result;
55557
55558   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
55559   argp2 = (Dali::Toolkit::Slider *)jarg2;
55560   if (!argp2) {
55561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
55562     return 0;
55563   }
55564   arg2 = *argp2;
55565   arg3 = (int)jarg3;
55566   {
55567     try {
55568       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
55569     } CALL_CATCH_EXCEPTION(0);
55570   }
55571
55572   jresult = result;
55573   return jresult;
55574 }
55575
55576
55577 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
55578   void * jresult ;
55579   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
55580
55581   {
55582     try {
55583       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
55584     } CALL_CATCH_EXCEPTION(0);
55585   }
55586
55587   jresult = (void *)result;
55588   return jresult;
55589 }
55590
55591
55592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
55593   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
55594
55595   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
55596   {
55597     try {
55598       delete arg1;
55599     } CALL_CATCH_EXCEPTION();
55600   }
55601
55602 }
55603
55604
55605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
55606   void * jresult ;
55607   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
55608
55609   {
55610     try {
55611       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
55612     } CALL_CATCH_EXCEPTION(0);
55613   }
55614
55615   jresult = (void *)result;
55616   return jresult;
55617 }
55618
55619
55620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
55621   void * jresult ;
55622   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
55623   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
55624
55625   arg1 = (Dali::Toolkit::Ruler *)jarg1;
55626   {
55627     try {
55628       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
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_2(void * jarg1) {
55638   void * jresult ;
55639   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
55640   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
55641
55642   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55643   if (!arg1) {
55644     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
55645     return 0;
55646   }
55647   {
55648     try {
55649       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
55650     } CALL_CATCH_EXCEPTION(0);
55651   }
55652
55653   jresult = (void *)result;
55654   return jresult;
55655 }
55656
55657
55658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
55659   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55660
55661   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55662   {
55663     try {
55664       delete arg1;
55665     } CALL_CATCH_EXCEPTION();
55666   }
55667
55668 }
55669
55670
55671 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
55672   void * jresult ;
55673   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55674   Dali::Toolkit::Ruler *result = 0 ;
55675
55676   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55677   {
55678     try {
55679       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
55680     } CALL_CATCH_EXCEPTION(0);
55681   }
55682
55683   jresult = (void *)result;
55684   return jresult;
55685 }
55686
55687
55688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(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)->operator ->();
55697     } CALL_CATCH_EXCEPTION(0);
55698   }
55699
55700   jresult = (void *)result;
55701   return jresult;
55702 }
55703
55704
55705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(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_Assign__SWIG_0(void * jarg1, void * jarg2) {
55723   void * jresult ;
55724   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55725   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
55726   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
55727
55728   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55729   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
55730   if (!arg2) {
55731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
55732     return 0;
55733   }
55734   {
55735     try {
55736       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
55737     } CALL_CATCH_EXCEPTION(0);
55738   }
55739
55740   jresult = (void *)result;
55741   return jresult;
55742 }
55743
55744
55745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
55746   void * jresult ;
55747   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55748   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
55749   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
55750
55751   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55752   arg2 = (Dali::Toolkit::Ruler *)jarg2;
55753   {
55754     try {
55755       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
55756     } CALL_CATCH_EXCEPTION(0);
55757   }
55758
55759   jresult = (void *)result;
55760   return jresult;
55761 }
55762
55763
55764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
55765   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55766
55767   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55768   {
55769     try {
55770       (arg1)->Reset();
55771     } CALL_CATCH_EXCEPTION();
55772   }
55773
55774 }
55775
55776
55777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
55778   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55779   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
55780
55781   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55782   arg2 = (Dali::Toolkit::Ruler *)jarg2;
55783   {
55784     try {
55785       (arg1)->Reset(arg2);
55786     } CALL_CATCH_EXCEPTION();
55787   }
55788
55789 }
55790
55791
55792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
55793   void * jresult ;
55794   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55795   Dali::Toolkit::Ruler *result = 0 ;
55796
55797   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55798   {
55799     try {
55800       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
55801     } CALL_CATCH_EXCEPTION(0);
55802   }
55803
55804   jresult = (void *)result;
55805   return jresult;
55806 }
55807
55808
55809 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
55810   float jresult ;
55811   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55812   float arg2 ;
55813   float arg3 ;
55814   float result;
55815
55816   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55817   arg2 = (float)jarg2;
55818   arg3 = (float)jarg3;
55819   {
55820     try {
55821       result = (float)(*arg1)->Snap(arg2,arg3);
55822     } CALL_CATCH_EXCEPTION(0);
55823   }
55824
55825   jresult = result;
55826   return jresult;
55827 }
55828
55829
55830 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
55831   float jresult ;
55832   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55833   float arg2 ;
55834   float result;
55835
55836   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55837   arg2 = (float)jarg2;
55838   {
55839     try {
55840       result = (float)(*arg1)->Snap(arg2);
55841     } CALL_CATCH_EXCEPTION(0);
55842   }
55843
55844   jresult = result;
55845   return jresult;
55846 }
55847
55848
55849 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
55850   float jresult ;
55851   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55852   unsigned int arg2 ;
55853   unsigned int *arg3 = 0 ;
55854   bool arg4 ;
55855   float result;
55856
55857   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55858   arg2 = (unsigned int)jarg2;
55859   arg3 = (unsigned int *)jarg3;
55860   arg4 = jarg4 ? true : false;
55861   {
55862     try {
55863       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
55864     } CALL_CATCH_EXCEPTION(0);
55865   }
55866
55867   jresult = result;
55868   return jresult;
55869 }
55870
55871
55872 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
55873   unsigned int jresult ;
55874   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55875   float arg2 ;
55876   bool arg3 ;
55877   unsigned int result;
55878
55879   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55880   arg2 = (float)jarg2;
55881   arg3 = jarg3 ? true : false;
55882   {
55883     try {
55884       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
55885     } CALL_CATCH_EXCEPTION(0);
55886   }
55887
55888   jresult = result;
55889   return jresult;
55890 }
55891
55892
55893 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
55894   unsigned int jresult ;
55895   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55896   unsigned int result;
55897
55898   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55899   {
55900     try {
55901       result = (unsigned int)(*arg1)->GetTotalPages();
55902     } CALL_CATCH_EXCEPTION(0);
55903   }
55904
55905   jresult = result;
55906   return jresult;
55907 }
55908
55909
55910 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
55911   int jresult ;
55912   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55913   Dali::Toolkit::Ruler::RulerType result;
55914
55915   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55916   {
55917     try {
55918       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
55919     } CALL_CATCH_EXCEPTION(0);
55920   }
55921
55922   jresult = (int)result;
55923   return jresult;
55924 }
55925
55926
55927 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
55928   unsigned int jresult ;
55929   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55930   bool result;
55931
55932   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55933   {
55934     try {
55935       result = (bool)(*arg1)->IsEnabled();
55936     } CALL_CATCH_EXCEPTION(0);
55937   }
55938
55939   jresult = result;
55940   return jresult;
55941 }
55942
55943
55944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
55945   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55946
55947   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55948   {
55949     try {
55950       (*arg1)->Enable();
55951     } CALL_CATCH_EXCEPTION();
55952   }
55953
55954 }
55955
55956
55957 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
55958   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55959
55960   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55961   {
55962     try {
55963       (*arg1)->Disable();
55964     } CALL_CATCH_EXCEPTION();
55965   }
55966
55967 }
55968
55969
55970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
55971   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55972   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
55973   Dali::Toolkit::RulerDomain *argp2 ;
55974
55975   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55976   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
55977   if (!argp2) {
55978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
55979     return ;
55980   }
55981   arg2 = *argp2;
55982   {
55983     try {
55984       (*arg1)->SetDomain(arg2);
55985     } CALL_CATCH_EXCEPTION();
55986   }
55987
55988 }
55989
55990
55991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
55992   void * jresult ;
55993   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
55994   Dali::Toolkit::RulerDomain *result = 0 ;
55995
55996   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
55997   {
55998     try {
55999       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
56000     } CALL_CATCH_EXCEPTION(0);
56001   }
56002
56003   jresult = (void *)result;
56004   return jresult;
56005 }
56006
56007
56008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
56009   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
56010
56011   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
56012   {
56013     try {
56014       (*arg1)->DisableDomain();
56015     } CALL_CATCH_EXCEPTION();
56016   }
56017
56018 }
56019
56020
56021 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
56022   float jresult ;
56023   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
56024   float arg2 ;
56025   float arg3 ;
56026   float arg4 ;
56027   float result;
56028
56029   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
56030   arg2 = (float)jarg2;
56031   arg3 = (float)jarg3;
56032   arg4 = (float)jarg4;
56033   {
56034     try {
56035       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
56036     } CALL_CATCH_EXCEPTION(0);
56037   }
56038
56039   jresult = result;
56040   return jresult;
56041 }
56042
56043
56044 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
56045   float jresult ;
56046   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
56047   float arg2 ;
56048   float arg3 ;
56049   float result;
56050
56051   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
56052   arg2 = (float)jarg2;
56053   arg3 = (float)jarg3;
56054   {
56055     try {
56056       result = (float)(*arg1)->Clamp(arg2,arg3);
56057     } CALL_CATCH_EXCEPTION(0);
56058   }
56059
56060   jresult = result;
56061   return jresult;
56062 }
56063
56064
56065 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
56066   float jresult ;
56067   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
56068   float arg2 ;
56069   float result;
56070
56071   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
56072   arg2 = (float)jarg2;
56073   {
56074     try {
56075       result = (float)(*arg1)->Clamp(arg2);
56076     } CALL_CATCH_EXCEPTION(0);
56077   }
56078
56079   jresult = result;
56080   return jresult;
56081 }
56082
56083
56084 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
56085   float jresult ;
56086   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
56087   float arg2 ;
56088   float arg3 ;
56089   float arg4 ;
56090   Dali::Toolkit::ClampState *arg5 = 0 ;
56091   float result;
56092
56093   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
56094   arg2 = (float)jarg2;
56095   arg3 = (float)jarg3;
56096   arg4 = (float)jarg4;
56097   arg5 = (Dali::Toolkit::ClampState *)jarg5;
56098   if (!arg5) {
56099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
56100     return 0;
56101   }
56102   {
56103     try {
56104       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
56105     } CALL_CATCH_EXCEPTION(0);
56106   }
56107
56108   jresult = result;
56109   return jresult;
56110 }
56111
56112
56113 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
56114   float jresult ;
56115   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
56116   float arg2 ;
56117   float arg3 ;
56118   float arg4 ;
56119   float arg5 ;
56120   float result;
56121
56122   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
56123   arg2 = (float)jarg2;
56124   arg3 = (float)jarg3;
56125   arg4 = (float)jarg4;
56126   arg5 = (float)jarg5;
56127   {
56128     try {
56129       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
56130     } CALL_CATCH_EXCEPTION(0);
56131   }
56132
56133   jresult = result;
56134   return jresult;
56135 }
56136
56137
56138 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
56139   float jresult ;
56140   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
56141   float arg2 ;
56142   float arg3 ;
56143   float arg4 ;
56144   float result;
56145
56146   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
56147   arg2 = (float)jarg2;
56148   arg3 = (float)jarg3;
56149   arg4 = (float)jarg4;
56150   {
56151     try {
56152       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
56153     } CALL_CATCH_EXCEPTION(0);
56154   }
56155
56156   jresult = result;
56157   return jresult;
56158 }
56159
56160
56161 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
56162   float jresult ;
56163   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
56164   float arg2 ;
56165   float arg3 ;
56166   float result;
56167
56168   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
56169   arg2 = (float)jarg2;
56170   arg3 = (float)jarg3;
56171   {
56172     try {
56173       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
56174     } CALL_CATCH_EXCEPTION(0);
56175   }
56176
56177   jresult = result;
56178   return jresult;
56179 }
56180
56181
56182 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
56183   float jresult ;
56184   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
56185   float arg2 ;
56186   float result;
56187
56188   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
56189   arg2 = (float)jarg2;
56190   {
56191     try {
56192       result = (float)(*arg1)->SnapAndClamp(arg2);
56193     } CALL_CATCH_EXCEPTION(0);
56194   }
56195
56196   jresult = result;
56197   return jresult;
56198 }
56199
56200
56201 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
56202   float jresult ;
56203   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
56204   float arg2 ;
56205   float arg3 ;
56206   float arg4 ;
56207   float arg5 ;
56208   Dali::Toolkit::ClampState *arg6 = 0 ;
56209   float result;
56210
56211   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
56212   arg2 = (float)jarg2;
56213   arg3 = (float)jarg3;
56214   arg4 = (float)jarg4;
56215   arg5 = (float)jarg5;
56216   arg6 = (Dali::Toolkit::ClampState *)jarg6;
56217   if (!arg6) {
56218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
56219     return 0;
56220   }
56221   {
56222     try {
56223       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
56224     } CALL_CATCH_EXCEPTION(0);
56225   }
56226
56227   jresult = result;
56228   return jresult;
56229 }
56230
56231
56232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
56233   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
56234
56235   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
56236   {
56237     try {
56238       (*arg1)->Reference();
56239     } CALL_CATCH_EXCEPTION();
56240   }
56241
56242 }
56243
56244
56245 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
56246   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
56247
56248   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
56249   {
56250     try {
56251       (*arg1)->Unreference();
56252     } CALL_CATCH_EXCEPTION();
56253   }
56254
56255 }
56256
56257
56258 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
56259   int jresult ;
56260   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
56261   int result;
56262
56263   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
56264   {
56265     try {
56266       result = (int)(*arg1)->ReferenceCount();
56267     } CALL_CATCH_EXCEPTION(0);
56268   }
56269
56270   jresult = result;
56271   return jresult;
56272 }
56273
56274
56275 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Empty(void * jarg1) {
56276   unsigned int jresult ;
56277   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
56278   bool result;
56279
56280   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
56281   {
56282     try {
56283       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
56284     } CALL_CATCH_EXCEPTION(0);
56285   }
56286
56287   jresult = result;
56288   return jresult;
56289 }
56290
56291
56292 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_GetConnectionCount(void * jarg1) {
56293   unsigned long jresult ;
56294   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
56295   std::size_t result;
56296
56297   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
56298   {
56299     try {
56300       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
56301     } CALL_CATCH_EXCEPTION(0);
56302   }
56303
56304   jresult = (unsigned long)result;
56305   return jresult;
56306 }
56307
56308
56309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Connect(void * jarg1, void * jarg2) {
56310   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
56311   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
56312
56313   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
56314   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
56315   {
56316     try {
56317       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
56318     } CALL_CATCH_EXCEPTION();
56319   }
56320
56321 }
56322
56323
56324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Disconnect(void * jarg1, void * jarg2) {
56325   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
56326   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
56327
56328   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
56329   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
56330   {
56331     try {
56332       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
56333     } CALL_CATCH_EXCEPTION();
56334   }
56335
56336 }
56337
56338
56339 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Emit(void * jarg1, void * jarg2) {
56340   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
56341   Dali::Toolkit::Control arg2 ;
56342   Dali::Toolkit::Control *argp2 ;
56343
56344   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
56345   argp2 = (Dali::Toolkit::Control *)jarg2;
56346   if (!argp2) {
56347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
56348     return ;
56349   }
56350   arg2 = *argp2;
56351   {
56352     try {
56353       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
56354     } CALL_CATCH_EXCEPTION();
56355   }
56356
56357 }
56358
56359
56360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewResourceReadySignal() {
56361   void * jresult ;
56362   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
56363
56364   {
56365     try {
56366       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
56367     } CALL_CATCH_EXCEPTION(0);
56368   }
56369
56370   jresult = (void *)result;
56371   return jresult;
56372 }
56373
56374
56375 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewResourceReadySignal(void * jarg1) {
56376   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
56377
56378   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
56379   {
56380     try {
56381       delete arg1;
56382     } CALL_CATCH_EXCEPTION();
56383   }
56384
56385 }
56386
56387 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_GetRefObjectPtr(Dali::BaseHandle *arg1) {
56388   Dali::RefObject *result = NULL;
56389
56390   if (arg1)
56391   {
56392     result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
56393   }
56394   return result;
56395 }
56396
56397 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
56398     return (Dali::RefObject *)jarg1;
56399 }
56400
56401 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
56402     return (Dali::SignalObserver *)jarg1;
56403 }
56404
56405 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
56406     return (Dali::ConnectionTrackerInterface *)jarg1;
56407 }
56408
56409 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
56410     return (Dali::BaseHandle *)jarg1;
56411 }
56412
56413 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
56414     return (Dali::BaseHandle *)jarg1;
56415 }
56416
56417 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
56418     return (Dali::BaseHandle *)jarg1;
56419 }
56420
56421 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
56422     return (Dali::BaseHandle *)jarg1;
56423 }
56424
56425 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
56426     return (Dali::BaseHandle *)jarg1;
56427 }
56428
56429 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
56430     return (Dali::BaseHandle *)jarg1;
56431 }
56432
56433 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
56434     return (Dali::BaseHandle *)jarg1;
56435 }
56436
56437 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
56438     return (Dali::BaseHandle *)jarg1;
56439 }
56440
56441 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
56442     return (Dali::BaseHandle *)jarg1;
56443 }
56444
56445 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
56446     return (Dali::BaseHandle *)jarg1;
56447 }
56448
56449 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VertexBuffer_SWIGUpcast(Dali::VertexBuffer *jarg1) {
56450     return (Dali::BaseHandle *)jarg1;
56451 }
56452
56453 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
56454     return (Dali::BaseHandle *)jarg1;
56455 }
56456
56457 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
56458     return (Dali::Handle *)jarg1;
56459 }
56460
56461 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
56462     return (Dali::Handle *)jarg1;
56463 }
56464
56465 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
56466     return (Dali::BaseHandle *)jarg1;
56467 }
56468
56469 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
56470     return (Dali::BaseHandle *)jarg1;
56471 }
56472
56473 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
56474     return (Dali::Handle *)jarg1;
56475 }
56476
56477 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchEvent *jarg1) {
56478     return (Dali::BaseHandle *)jarg1;
56479 }
56480
56481 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Hover_SWIGUpcast(Dali::HoverEvent *jarg1) {
56482     return (Dali::BaseHandle *)jarg1;
56483 }
56484
56485 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Wheel_SWIGUpcast(Dali::WheelEvent *jarg1) {
56486     return (Dali::BaseHandle *)jarg1;
56487 }
56488
56489 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Key_SWIGUpcast(Dali::KeyEvent *jarg1) {
56490     return (Dali::BaseHandle *)jarg1;
56491 }
56492
56493 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
56494     return (Dali::Handle *)jarg1;
56495 }
56496
56497 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
56498     return (Dali::GestureDetector *)jarg1;
56499 }
56500
56501 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
56502     return (Dali::Gesture *)jarg1;
56503 }
56504
56505 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
56506     return (Dali::Handle *)jarg1;
56507 }
56508
56509 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
56510     return (Dali::Actor *)jarg1;
56511 }
56512
56513 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
56514     return (Dali::RefObject *)jarg1;
56515 }
56516
56517 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
56518     return (Dali::Actor *)jarg1;
56519 }
56520
56521 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
56522     return (Dali::GestureDetector *)jarg1;
56523 }
56524
56525 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
56526     return (Dali::Gesture *)jarg1;
56527 }
56528
56529 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
56530     return (Dali::GestureDetector *)jarg1;
56531 }
56532
56533 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
56534     return (Dali::Gesture *)jarg1;
56535 }
56536
56537 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
56538     return (Dali::GestureDetector *)jarg1;
56539 }
56540
56541 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
56542     return (Dali::Gesture *)jarg1;
56543 }
56544
56545 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
56546     return (Dali::BaseHandle *)jarg1;
56547 }
56548
56549 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
56550     return (Dali::Handle *)jarg1;
56551 }
56552
56553 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
56554     return (Dali::Handle *)jarg1;
56555 }
56556
56557 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
56558     return (Dali::Handle *)jarg1;
56559 }
56560
56561 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
56562     return (Dali::RefObject *)jarg1;
56563 }
56564
56565 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
56566     return (Dali::Actor *)jarg1;
56567 }
56568
56569 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
56570     return (Dali::BaseHandle *)jarg1;
56571 }
56572
56573 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
56574     return (Dali::BaseHandle *)jarg1;
56575 }
56576
56577 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
56578     return (Dali::BaseHandle *)jarg1;
56579 }
56580
56581 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
56582     return (Dali::CustomActorImpl *)jarg1;
56583 }
56584
56585 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
56586     return (Dali::CustomActor *)jarg1;
56587 }
56588
56589 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
56590     return (Dali::BaseHandle *)jarg1;
56591 }
56592
56593 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
56594     return (Dali::Toolkit::Control *)jarg1;
56595 }
56596
56597 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
56598     return (Dali::Toolkit::Control *)jarg1;
56599 }
56600
56601 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
56602     return (Dali::Toolkit::Button *)jarg1;
56603 }
56604
56605 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
56606     return (Dali::Toolkit::Button *)jarg1;
56607 }
56608
56609 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
56610     return (Dali::Toolkit::Button *)jarg1;
56611 }
56612
56613 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
56614     return (Dali::Toolkit::Control *)jarg1;
56615 }
56616
56617 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
56618     return (Dali::Toolkit::Control *)jarg1;
56619 }
56620
56621 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
56622     return (Dali::Toolkit::Control *)jarg1;
56623 }
56624
56625 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
56626     return (Dali::Toolkit::Control *)jarg1;
56627 }
56628
56629 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
56630     return (Dali::Toolkit::Control *)jarg1;
56631 }
56632
56633 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
56634     return (Dali::RefObject *)jarg1;
56635 }
56636
56637 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
56638     return (Dali::Toolkit::Scrollable *)jarg1;
56639 }
56640
56641 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
56642     return (Dali::BaseHandle *)jarg1;
56643 }
56644
56645 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
56646     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
56647 }
56648
56649 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
56650     return (Dali::RefObject *)jarg1;
56651 }
56652
56653 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
56654     return (Dali::Toolkit::Ruler *)jarg1;
56655 }
56656
56657 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
56658     return (Dali::Toolkit::Ruler *)jarg1;
56659 }
56660
56661 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
56662     return (Dali::Toolkit::Scrollable *)jarg1;
56663 }
56664
56665 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
56666     return (Dali::Toolkit::Control *)jarg1;
56667 }
56668
56669
56670 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
56671     return (Dali::Toolkit::Control *)jarg1;
56672 }
56673
56674 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
56675     return (Dali::BaseHandle *)jarg1;
56676 }
56677
56678 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
56679     return (Dali::BaseHandle *)jarg1;
56680 }
56681
56682 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
56683     return (Dali::Toolkit::Control *)jarg1;
56684 }
56685
56686 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
56687     return (Dali::Toolkit::Control *)jarg1;
56688 }
56689
56690 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
56691     return (Dali::Toolkit::Control *)jarg1;
56692 }
56693
56694 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
56695     return (Dali::Toolkit::Control *)jarg1;
56696 }
56697
56698 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
56699     return (Dali::Toolkit::Control *)jarg1;
56700 }
56701
56702 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
56703     return (Dali::Toolkit::Control *)jarg1;
56704 }
56705
56706 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
56707     return (Dali::Toolkit::PageTurnView *)jarg1;
56708 }
56709
56710 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
56711     return (Dali::Toolkit::PageTurnView *)jarg1;
56712 }
56713
56714 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
56715     return (Dali::Toolkit::Button *)jarg1;
56716 }
56717
56718 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
56719     return (Dali::BaseHandle *)jarg1;
56720 }
56721
56722 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
56723     return (Dali::BaseHandle *)jarg1;
56724 }
56725
56726 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
56727     return (Dali::BaseHandle *)jarg1;
56728 }
56729
56730 /*
56731  * Widget binding
56732  */
56733 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Widget_SWIGUpcast(Dali::Widget *jarg1) {
56734     return (Dali::BaseHandle *)jarg1;
56735 }
56736
56737 SWIGEXPORT Dali::BaseObject * SWIGSTDCALL CSharp_Dali_WidgetImpl_SWIGUpcast(Dali::Internal::Adaptor::Widget *jarg1) {
56738     return (Dali::BaseObject *)jarg1;
56739 }
56740
56741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_0() {
56742   void * jresult ;
56743   Dali::Widget result;
56744
56745   {
56746     try {
56747       result = Dali::Widget::New();
56748     } CALL_CATCH_EXCEPTION(0);
56749   }
56750
56751   jresult = new Dali::Widget((const Dali::Widget &)result);
56752   return jresult;
56753 }
56754
56755
56756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_1(void * jarg1) {
56757   void * jresult ;
56758   Dali::Internal::Adaptor::Widget *arg1 = 0 ;
56759   Dali::Widget result;
56760
56761   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
56762
56763   if (!arg1) {
56764     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Internal::Adaptor::Widget & type is null", 0);
56765     return 0;
56766   }
56767   {
56768     try {
56769       jresult = new Dali::Widget(arg1);
56770     } CALL_CATCH_EXCEPTION(0);
56771   }
56772   return jresult;
56773 }
56774
56775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Widget() {
56776   void * jresult ;
56777   Dali::Widget *result = 0 ;
56778
56779   {
56780     try {
56781       result = (Dali::Widget *)new Dali::Widget();
56782     } CALL_CATCH_EXCEPTION(0);
56783   }
56784   jresult = (void *)result;
56785   return jresult;
56786 }
56787
56788
56789 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_Assign(void * jarg1, void * jarg2) {
56790   void * jresult ;
56791   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
56792   Dali::Widget *arg2 = 0 ;
56793   Dali::Widget *result = 0 ;
56794
56795   arg1 = (Dali::Widget *)jarg1;
56796   arg2 = (Dali::Widget *)jarg2;
56797   if (!arg2) {
56798     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget const & type is null", 0);
56799     return 0;
56800   }
56801   {
56802     try {
56803       result = (Dali::Widget *) &(arg1)->operator =((Dali::Widget const &)*arg2);
56804     } CALL_CATCH_EXCEPTION(0);
56805   }
56806   jresult = (void *)result;
56807   return jresult;
56808 }
56809
56810 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Widget(void * jarg1) {
56811   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
56812
56813   arg1 = (Dali::Widget *)jarg1;
56814   {
56815     try {
56816       delete arg1;
56817     } CALL_CATCH_EXCEPTION();
56818   }
56819 }
56820
56821 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetImpl_New() {
56822   void * jresult ;
56823   SwigDirector_WidgetImpl* result;
56824   {
56825     try {
56826       result = new SwigDirector_WidgetImpl();
56827     } CALL_CATCH_EXCEPTION(0);
56828   }
56829   jresult = result;
56830   return jresult;
56831 }
56832
56833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreate(void * jarg1, char * jarg2, void * jarg3) {
56834   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
56835   std::string *arg2 = 0 ;
56836   Dali::Window arg3 ;
56837   Dali::Window *argp3 ;
56838
56839   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
56840   if (!jarg2) {
56841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
56842     return ;
56843   }
56844   std::string arg2_str(jarg2);
56845   arg2 = &arg2_str;
56846   argp3 = (Dali::Window *)jarg3;
56847   if (!argp3) {
56848     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
56849     return ;
56850   }
56851   arg3 = *argp3;
56852   {
56853     try {
56854       (arg1)->OnCreate((std::string const &)*arg2,arg3);
56855     } CALL_CATCH_EXCEPTION();
56856   }
56857 }
56858
56859
56860 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, void * jarg3) {
56861   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
56862   std::string *arg2 = 0 ;
56863   Dali::Window arg3 ;
56864   Dali::Window *argp3 ;
56865
56866   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
56867   if (!jarg2) {
56868     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
56869     return ;
56870   }
56871   std::string arg2_str(jarg2);
56872   arg2 = &arg2_str;
56873   argp3 = (Dali::Window *)jarg3;
56874   if (!argp3) {
56875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
56876     return ;
56877   }
56878   arg3 = *argp3;
56879   {
56880     try {
56881       (arg1)->Dali::Internal::Adaptor::Widget::OnCreate((std::string const &)*arg2,arg3);
56882     } CALL_CATCH_EXCEPTION();
56883   }
56884 }
56885
56886
56887 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminate(void * jarg1, char * jarg2, int jarg3) {
56888   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
56889   std::string *arg2 = 0 ;
56890   Dali::Widget::Termination arg3 ;
56891
56892   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
56893   if (!jarg2) {
56894     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
56895     return ;
56896   }
56897   std::string arg2_str(jarg2);
56898   arg2 = &arg2_str;
56899   arg3 = (Dali::Widget::Termination)jarg3;
56900   {
56901     try {
56902       (arg1)->OnTerminate((std::string const &)*arg2,arg3);
56903     } CALL_CATCH_EXCEPTION();
56904   }
56905 }
56906
56907
56908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
56909   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
56910   std::string *arg2 = 0 ;
56911   Dali::Widget::Termination arg3 ;
56912
56913   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
56914   if (!jarg2) {
56915     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
56916     return ;
56917   }
56918   std::string arg2_str(jarg2);
56919   arg2 = &arg2_str;
56920   arg3 = (Dali::Widget::Termination)jarg3;
56921   {
56922     try {
56923       (arg1)->Dali::Internal::Adaptor::Widget::OnTerminate((std::string const &)*arg2,arg3);
56924     } CALL_CATCH_EXCEPTION();
56925   }
56926 }
56927
56928
56929 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPause(void * jarg1) {
56930   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
56931
56932   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
56933   {
56934     try {
56935       (arg1)->OnPause();
56936     } CALL_CATCH_EXCEPTION();
56937   }
56938 }
56939
56940
56941 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPauseSwigExplicitWidgetImpl(void * jarg1) {
56942   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
56943
56944   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
56945   {
56946     try {
56947       (arg1)->Dali::Internal::Adaptor::Widget::OnPause();
56948     } CALL_CATCH_EXCEPTION();
56949   }
56950 }
56951
56952
56953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResume(void * jarg1) {
56954   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
56955
56956   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
56957   {
56958     try {
56959       (arg1)->OnResume();
56960     } CALL_CATCH_EXCEPTION();
56961   }
56962 }
56963
56964
56965 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResumeSwigExplicitWidgetImpl(void * jarg1) {
56966   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
56967
56968   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
56969   {
56970     try {
56971       (arg1)->Dali::Internal::Adaptor::Widget::OnResume();
56972     } CALL_CATCH_EXCEPTION();
56973   }
56974 }
56975
56976
56977 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResize(void * jarg1, void * jarg2) {
56978   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
56979   Dali::Window arg2 ;
56980   Dali::Window *argp2 ;
56981
56982   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
56983   argp2 = (Dali::Window *)jarg2;
56984   if (!argp2) {
56985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
56986     return ;
56987   }
56988   arg2 = *argp2;
56989   {
56990     try {
56991       (arg1)->OnResize(arg2);
56992     } CALL_CATCH_EXCEPTION();
56993   }
56994 }
56995
56996
56997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResizeSwigExplicitWidgetImpl(void * jarg1, void * jarg2) {
56998   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
56999   Dali::Window arg2 ;
57000   Dali::Window *argp2 ;
57001
57002   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
57003   argp2 = (Dali::Window *)jarg2;
57004   if (!argp2) {
57005     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
57006     return ;
57007   }
57008   arg2 = *argp2;
57009   {
57010     try {
57011       (arg1)->Dali::Internal::Adaptor::Widget::OnResize(arg2);
57012     } CALL_CATCH_EXCEPTION();
57013   }
57014 }
57015
57016
57017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdate(void * jarg1, char * jarg2, int jarg3) {
57018   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
57019   std::string *arg2 = 0 ;
57020   int arg3 ;
57021
57022   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
57023   if (!jarg2) {
57024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57025     return ;
57026   }
57027   std::string arg2_str(jarg2);
57028   arg2 = &arg2_str;
57029   arg3 = (int)jarg3;
57030   {
57031     try {
57032       (arg1)->OnUpdate((std::string const &)*arg2,arg3);
57033     } CALL_CATCH_EXCEPTION();
57034   }
57035 }
57036
57037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
57038   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
57039   std::string *arg2 = 0 ;
57040   int arg3 ;
57041
57042   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
57043   if (!jarg2) {
57044     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57045     return ;
57046   }
57047   std::string arg2_str(jarg2);
57048   arg2 = &arg2_str;
57049   arg3 = (int)jarg3;
57050   {
57051     try {
57052       (arg1)->Dali::Internal::Adaptor::Widget::OnUpdate((std::string const &)*arg2,arg3);
57053     } CALL_CATCH_EXCEPTION();
57054   }
57055 }
57056
57057
57058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
57059   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
57060   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
57061   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
57062
57063   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
57064   arg2 = (Dali::SlotObserver *)jarg2;
57065   arg3 = (Dali::CallbackBase *)jarg3;
57066   {
57067     try {
57068       (arg1)->SignalConnected(arg2,arg3);
57069     } CALL_CATCH_EXCEPTION();
57070   }
57071 }
57072
57073 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
57074   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
57075   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
57076   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
57077
57078   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
57079   arg2 = (Dali::SlotObserver *)jarg2;
57080   arg3 = (Dali::CallbackBase *)jarg3;
57081   {
57082     try {
57083       (arg1)->Dali::Internal::Adaptor::Widget::SignalConnected(arg2,arg3);
57084     } CALL_CATCH_EXCEPTION();
57085   }
57086 }
57087
57088
57089 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
57090   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
57091   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
57092   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
57093
57094   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
57095   arg2 = (Dali::SlotObserver *)jarg2;
57096   arg3 = (Dali::CallbackBase *)jarg3;
57097   {
57098     try {
57099       (arg1)->SignalDisconnected(arg2,arg3);
57100     } CALL_CATCH_EXCEPTION();
57101   }
57102 }
57103
57104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
57105   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
57106   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
57107   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
57108
57109   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
57110   arg2 = (Dali::SlotObserver *)jarg2;
57111   arg3 = (Dali::CallbackBase *)jarg3;
57112   {
57113     try {
57114       (arg1)->Dali::Internal::Adaptor::Widget::SignalDisconnected(arg2,arg3);
57115     } CALL_CATCH_EXCEPTION();
57116   }
57117 }
57118
57119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetContentInfo(void * jarg1, char * jarg2) {
57120   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
57121   std::string *arg2 = 0 ;
57122
57123   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
57124   if (!jarg2) {
57125     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57126     return ;
57127   }
57128   std::string arg2_str(jarg2);
57129   arg2 = &arg2_str;
57130   {
57131     try {
57132       (arg1)->SetContentInfo((std::string const &)*arg2);
57133     } CALL_CATCH_EXCEPTION();
57134   }
57135 }
57136
57137 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetImpl(void * jarg1, void * jarg2) {
57138   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
57139   Dali::Internal::Adaptor::Widget::Impl *arg2 = (Dali::Internal::Adaptor::Widget::Impl *) 0 ;
57140
57141   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
57142   arg2 = (Dali::Internal::Adaptor::Widget::Impl *)jarg2;
57143   {
57144     try {
57145       (arg1)->SetImpl(arg2);
57146     } CALL_CATCH_EXCEPTION();
57147   }
57148 }
57149
57150
57151 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) {
57152   SwigDirector_WidgetImpl *director = static_cast<SwigDirector_WidgetImpl *>(objarg);
57153   if (director) {
57154     director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback7);
57155   }
57156 }
57157
57158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_GetImplementation__SWIG_0(void * jarg1) {
57159   void * jresult ;
57160   Dali::Widget *arg1 = 0 ;
57161   SwigDirector_WidgetImpl *result = 0 ;
57162
57163   arg1 = (Dali::Widget *)jarg1;
57164   if (!arg1) {
57165     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget & type is null", 0);
57166     return 0;
57167   }
57168   {
57169     try {
57170       result = (SwigDirector_WidgetImpl *) &Dali::Internal::Adaptor::GetImplementation(*arg1);
57171     } CALL_CATCH_EXCEPTION(0);
57172   }
57173   jresult = (void*) result;
57174   return jresult;
57175 }
57176
57177
57178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_New(int jarg1, char * jarg2, char * jarg3) {
57179   void * jresult ;
57180   int *arg1 = (int *) 0 ;
57181   char ***arg2 ;
57182   std::string *arg3 = 0 ;
57183   Dali::WidgetApplication result;
57184   {
57185     int index = 0;
57186     int length = 0;
57187     char *retPtr;
57188     char *nextPtr;
57189     argWidgetC = jarg1;
57190     argWidgetV = new char*[jarg1 + 1];
57191
57192     retPtr = strtok_r( jarg2, " ", &nextPtr);
57193     if( retPtr )
57194     {
57195       length = strlen(retPtr);
57196     }
57197     argWidgetV[index] = new char[length + 1];
57198     if( retPtr )
57199     {
57200       strncpy(argWidgetV[index], retPtr, length);
57201     }
57202     argWidgetV[index][length] = '\0';
57203     index++;
57204
57205     while (index < jarg1)
57206     {
57207       length = 0;
57208       retPtr = strtok_r(NULL, " ", &nextPtr);
57209       if( retPtr )
57210       {
57211         length = strlen(retPtr);
57212       }
57213       argWidgetV[index] = new char[length + 1];
57214       if( retPtr )
57215       {
57216         strncpy(argWidgetV[index], retPtr, length);
57217       }
57218       argWidgetV[index][length] = '\0';
57219       index++;
57220     }
57221
57222     argWidgetV[jarg1] = NULL;
57223     argWidgetC = jarg1;
57224
57225     arg1 = &argWidgetC;
57226     arg2 = &argWidgetV;
57227   }
57228
57229   if (!jarg3) {
57230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57231     return 0;
57232   }
57233   std::string arg3_str(jarg3);
57234   arg3 = &arg3_str;
57235   {
57236     try {
57237       result = Dali::WidgetApplication::New(arg1,arg2,(std::string const &)*arg3);
57238     } CALL_CATCH_EXCEPTION(0);
57239   }
57240   jresult = new Dali::WidgetApplication((const Dali::WidgetApplication &)result);
57241   return jresult;
57242 }
57243
57244
57245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_0() {
57246   void * jresult ;
57247   Dali::WidgetApplication *result = 0 ;
57248
57249   {
57250     try {
57251       result = (Dali::WidgetApplication *)new Dali::WidgetApplication();
57252     } CALL_CATCH_EXCEPTION(0);
57253   }
57254   jresult = (void *)result;
57255   return jresult;
57256 }
57257
57258
57259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_1(void * jarg1) {
57260   void * jresult ;
57261   Dali::WidgetApplication *arg1 = 0 ;
57262   Dali::WidgetApplication *result = 0 ;
57263
57264   arg1 = (Dali::WidgetApplication *)jarg1;
57265   if (!arg1) {
57266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
57267     return 0;
57268   }
57269   {
57270     try {
57271       result = (Dali::WidgetApplication *)new Dali::WidgetApplication((Dali::WidgetApplication const &)*arg1);
57272     } CALL_CATCH_EXCEPTION(0);
57273   }
57274   jresult = (void *)result;
57275   return jresult;
57276 }
57277
57278
57279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_Assign(void * jarg1, void * jarg2) {
57280   void * jresult ;
57281   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
57282   Dali::WidgetApplication *arg2 = 0 ;
57283   Dali::WidgetApplication *result = 0 ;
57284
57285   arg1 = (Dali::WidgetApplication *)jarg1;
57286   arg2 = (Dali::WidgetApplication *)jarg2;
57287   if (!arg2) {
57288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
57289     return 0;
57290   }
57291   {
57292     try {
57293       result = (Dali::WidgetApplication *) &(arg1)->operator =((Dali::WidgetApplication const &)*arg2);
57294     } CALL_CATCH_EXCEPTION(0);
57295   }
57296   jresult = (void *)result;
57297   return jresult;
57298 }
57299
57300
57301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WidgetApplication(void * jarg1) {
57302   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
57303
57304   arg1 = (Dali::WidgetApplication *)jarg1;
57305   {
57306     try {
57307       delete arg1;
57308       if( argWidgetV )
57309       {
57310         // free string data
57311         for( int i=0; i < argWidgetC+1; i++)
57312         {
57313           delete [] argWidgetV[i];
57314         }
57315         delete [] argWidgetV;
57316       }
57317     } CALL_CATCH_EXCEPTION();
57318   }
57319 }
57320
57321
57322 typedef Dali::Widget*(SWIGSTDCALL *CSharpCreateWidgetFunction)(const std::string&);
57323 CSharpCreateWidgetFunction _CSharpCreateWidgetFunction = NULL;
57324
57325 static Dali::Widget SWIGSTDCALL WidgetFactoryFunction( const std::string& widgetName )
57326 {
57327   Widget* widget = _CSharpCreateWidgetFunction( widgetName.c_str() );
57328   return *widget;
57329 }
57330
57331 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetApplication_RegisterWidgetCreatingFunction(void * jarg1, char** jarg2, void * jarg3) {
57332   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
57333   std::string *arg2 = 0 ;
57334
57335   arg1 = (Dali::WidgetApplication *)jarg1;
57336   if (!jarg2) {
57337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57338     return ;
57339   }
57340   std::string arg2_str(*jarg2);
57341   arg2 = &arg2_str;
57342
57343   if(!_CSharpCreateWidgetFunction)
57344   {
57345     _CSharpCreateWidgetFunction = (Dali::Widget*(*)(const std::string&))jarg3;
57346   }
57347
57348   {
57349     try {
57350       (arg1)->RegisterWidgetCreatingFunction((std::string const &)*arg2, WidgetFactoryFunction);
57351     } CALL_CATCH_EXCEPTION();
57352   }
57353   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
57354 }
57355
57356
57357 //for PixelBuffer and ImageLoading
57358
57359 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelBuffer_SWIGUpcast(Dali::Devel::PixelBuffer *jarg1) {
57360     return (Dali::BaseHandle *)jarg1;
57361 }
57362
57363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_New(unsigned int jarg1, unsigned int jarg2, int jarg3) {
57364   void * jresult ;
57365   unsigned int arg1 ;
57366   unsigned int arg2 ;
57367   Dali::Pixel::Format arg3 ;
57368   Dali::Devel::PixelBuffer result;
57369
57370   arg1 = (unsigned int)jarg1;
57371   arg2 = (unsigned int)jarg2;
57372   arg3 = (Dali::Pixel::Format)jarg3;
57373   {
57374     try {
57375       result = Dali::Devel::PixelBuffer::New(arg1,arg2,arg3);
57376     } CALL_CATCH_EXCEPTION(0);
57377   }
57378   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
57379   return jresult;
57380 }
57381
57382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_0() {
57383   void * jresult ;
57384   Dali::Devel::PixelBuffer *result = 0 ;
57385
57386   {
57387     try {
57388       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer();
57389     } CALL_CATCH_EXCEPTION(0);
57390   }
57391   jresult = (void *)result;
57392   return jresult;
57393 }
57394
57395
57396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelBuffer(void * jarg1) {
57397   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
57398
57399   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57400   {
57401     try {
57402       delete arg1;
57403     } CALL_CATCH_EXCEPTION();
57404   }
57405 }
57406
57407
57408 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_1(void * jarg1) {
57409   void * jresult ;
57410   Dali::Devel::PixelBuffer *arg1 = 0 ;
57411   Dali::Devel::PixelBuffer *result = 0 ;
57412
57413   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57414   if (!arg1) {
57415     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
57416     return 0;
57417   }
57418   {
57419     try {
57420       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer((Dali::Devel::PixelBuffer const &)*arg1);
57421     } CALL_CATCH_EXCEPTION(0);
57422   }
57423   jresult = (void *)result;
57424   return jresult;
57425 }
57426
57427
57428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Assign(void * jarg1, void * jarg2) {
57429   void * jresult ;
57430   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
57431   Dali::Devel::PixelBuffer *arg2 = 0 ;
57432   Dali::Devel::PixelBuffer *result = 0 ;
57433
57434   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57435   arg2 = (Dali::Devel::PixelBuffer *)jarg2;
57436   if (!arg2) {
57437     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
57438     return 0;
57439   }
57440   {
57441     try {
57442       result = (Dali::Devel::PixelBuffer *) &(arg1)->operator =((Dali::Devel::PixelBuffer const &)*arg2);
57443     } CALL_CATCH_EXCEPTION(0);
57444   }
57445   jresult = (void *)result;
57446   return jresult;
57447 }
57448
57449
57450 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Convert(void * jarg1) {
57451   void * jresult ;
57452   Dali::Devel::PixelBuffer *arg1 = 0 ;
57453   Dali::PixelData result;
57454
57455   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57456   if (!arg1) {
57457     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer & type is null", 0);
57458     return 0;
57459   }
57460   {
57461     try {
57462       result = Dali::Devel::PixelBuffer::Convert(*arg1);
57463     } CALL_CATCH_EXCEPTION(0);
57464   }
57465   jresult = new Dali::PixelData((const Dali::PixelData &)result);
57466   return jresult;
57467 }
57468
57469
57470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_CreatePixelData(void * jarg1) {
57471   void * jresult ;
57472   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
57473   Dali::PixelData result;
57474
57475   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57476   {
57477     try {
57478       result = ((Dali::Devel::PixelBuffer const *)arg1)->CreatePixelData();
57479     } CALL_CATCH_EXCEPTION(0);
57480   }
57481   jresult = new Dali::PixelData((const Dali::PixelData &)result);
57482   return jresult;
57483 }
57484
57485
57486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_GetBuffer(void * jarg1) {
57487   void * jresult ;
57488   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
57489   unsigned char *result = 0 ;
57490
57491   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57492   {
57493     try {
57494       result = (unsigned char *)(arg1)->GetBuffer();
57495     } CALL_CATCH_EXCEPTION(0);
57496   }
57497    jresult = (void *)result;
57498    return jresult;
57499 }
57500
57501 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetWidth(void * jarg1) {
57502   unsigned int jresult ;
57503   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
57504   unsigned int result;
57505
57506   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57507   {
57508     try {
57509       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetWidth();
57510     } CALL_CATCH_EXCEPTION(0);
57511   }
57512   jresult = result;
57513   return jresult;
57514 }
57515
57516
57517 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetHeight(void * jarg1) {
57518   unsigned int jresult ;
57519   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
57520   unsigned int result;
57521
57522   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57523   {
57524     try {
57525       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetHeight();
57526     } CALL_CATCH_EXCEPTION(0);
57527   }
57528   jresult = result;
57529   return jresult;
57530 }
57531
57532
57533 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetPixelFormat(void * jarg1) {
57534   int jresult ;
57535   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
57536   Dali::Pixel::Format result;
57537
57538   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57539   {
57540     try {
57541       result = (Dali::Pixel::Format)((Dali::Devel::PixelBuffer const *)arg1)->GetPixelFormat();
57542     } CALL_CATCH_EXCEPTION(0);
57543   }
57544   jresult = (int)result;
57545   return jresult;
57546 }
57547
57548
57549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_0(void * jarg1, void * jarg2, float jarg3, unsigned int jarg4) {
57550   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
57551   Dali::Devel::PixelBuffer arg2 ;
57552   float arg3 ;
57553   bool arg4 ;
57554   Dali::Devel::PixelBuffer *argp2 ;
57555
57556   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57557   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
57558   if (!argp2) {
57559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
57560     return ;
57561   }
57562   arg2 = *argp2;
57563   arg3 = (float)jarg3;
57564   arg4 = jarg4 ? true : false;
57565   {
57566     try {
57567       (arg1)->ApplyMask(arg2,arg3,arg4);
57568     } CALL_CATCH_EXCEPTION();
57569   }
57570 }
57571
57572
57573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
57574   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
57575   Dali::Devel::PixelBuffer arg2 ;
57576   float arg3 ;
57577   Dali::Devel::PixelBuffer *argp2 ;
57578
57579   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57580   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
57581   if (!argp2) {
57582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
57583     return ;
57584   }
57585   arg2 = *argp2;
57586   arg3 = (float)jarg3;
57587   {
57588     try {
57589       (arg1)->ApplyMask(arg2,arg3);
57590     } CALL_CATCH_EXCEPTION();
57591   }
57592 }
57593
57594
57595 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_2(void * jarg1, void * jarg2) {
57596   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
57597   Dali::Devel::PixelBuffer arg2 ;
57598   Dali::Devel::PixelBuffer *argp2 ;
57599
57600   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57601   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
57602   if (!argp2) {
57603     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
57604     return ;
57605   }
57606   arg2 = *argp2;
57607   {
57608     try {
57609       (arg1)->ApplyMask(arg2);
57610     } CALL_CATCH_EXCEPTION();
57611   }
57612 }
57613
57614 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyGaussianBlur(void * jarg1, float jarg2) {
57615   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
57616   float arg2 ;
57617
57618   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57619   arg2 = (float)jarg2;
57620   {
57621     try {
57622       (arg1)->ApplyGaussianBlur(arg2);
57623     } CALL_CATCH_EXCEPTION();
57624   }
57625 }
57626
57627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Crop(void * jarg1, unsigned short jarg2, unsigned short jarg3, unsigned short jarg4, unsigned short jarg5) {
57628   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
57629   uint16_t arg2 ;
57630   uint16_t arg3 ;
57631   uint16_t arg4 ;
57632   uint16_t arg5 ;
57633
57634   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57635   arg2 = (uint16_t)jarg2;
57636   arg3 = (uint16_t)jarg3;
57637   arg4 = (uint16_t)jarg4;
57638   arg5 = (uint16_t)jarg5;
57639   {
57640     try {
57641       (arg1)->Crop(arg2,arg3,arg4,arg5);
57642     } CALL_CATCH_EXCEPTION();
57643   }
57644 }
57645
57646
57647 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Resize(void * jarg1, unsigned short jarg2, unsigned short jarg3) {
57648   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
57649   uint16_t arg2 ;
57650   uint16_t arg3 ;
57651
57652   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57653   arg2 = (uint16_t)jarg2;
57654   arg3 = (uint16_t)jarg3;
57655   {
57656     try {
57657       (arg1)->Resize(arg2,arg3);
57658     } CALL_CATCH_EXCEPTION();
57659   }
57660 }
57661
57662 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PixelBuffer_Rotate(void * jarg1, void* jarg2) {
57663   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
57664   Dali::Degree * arg2 ;
57665
57666   bool result = false;
57667
57668   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
57669   arg2 = (Dali::Degree *)jarg2;
57670   {
57671     try {
57672       result = (arg1)->Rotate(*arg2);
57673     } CALL_CATCH_EXCEPTION(false);
57674   }
57675   return result;
57676 }
57677
57678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
57679   void * jresult ;
57680   std::string *arg1 = 0 ;
57681   Dali::ImageDimensions arg2 ;
57682   Dali::FittingMode::Type arg3 ;
57683   Dali::SamplingMode::Type arg4 ;
57684   bool arg5 ;
57685   Dali::ImageDimensions *argp2 ;
57686   Dali::Devel::PixelBuffer result;
57687
57688   if (!jarg1) {
57689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57690     return 0;
57691   }
57692   std::string arg1_str(jarg1);
57693   arg1 = &arg1_str;
57694   argp2 = (Dali::ImageDimensions *)jarg2;
57695   if (!argp2) {
57696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
57697     return 0;
57698   }
57699   arg2 = *argp2;
57700   arg3 = (Dali::FittingMode::Type)jarg3;
57701   arg4 = (Dali::SamplingMode::Type)jarg4;
57702   arg5 = jarg5 ? true : false;
57703   {
57704     try {
57705       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4,arg5);
57706     } CALL_CATCH_EXCEPTION(0);
57707   }
57708   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
57709   return jresult;
57710 }
57711
57712
57713 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
57714   void * jresult ;
57715   std::string *arg1 = 0 ;
57716   Dali::ImageDimensions arg2 ;
57717   Dali::FittingMode::Type arg3 ;
57718   Dali::SamplingMode::Type arg4 ;
57719   Dali::ImageDimensions *argp2 ;
57720   Dali::Devel::PixelBuffer result;
57721
57722   if (!jarg1) {
57723     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57724     return 0;
57725   }
57726   std::string arg1_str(jarg1);
57727   arg1 = &arg1_str;
57728   argp2 = (Dali::ImageDimensions *)jarg2;
57729   if (!argp2) {
57730     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
57731     return 0;
57732   }
57733   arg2 = *argp2;
57734   arg3 = (Dali::FittingMode::Type)jarg3;
57735   arg4 = (Dali::SamplingMode::Type)jarg4;
57736   {
57737     try {
57738       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4);
57739     } CALL_CATCH_EXCEPTION(0);
57740   }
57741   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
57742   return jresult;
57743 }
57744
57745
57746 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
57747   void * jresult ;
57748   std::string *arg1 = 0 ;
57749   Dali::ImageDimensions arg2 ;
57750   Dali::FittingMode::Type arg3 ;
57751   Dali::ImageDimensions *argp2 ;
57752   Dali::Devel::PixelBuffer result;
57753
57754   if (!jarg1) {
57755     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57756     return 0;
57757   }
57758   std::string arg1_str(jarg1);
57759   arg1 = &arg1_str;
57760   argp2 = (Dali::ImageDimensions *)jarg2;
57761   if (!argp2) {
57762     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
57763     return 0;
57764   }
57765   arg2 = *argp2;
57766   arg3 = (Dali::FittingMode::Type)jarg3;
57767   {
57768     try {
57769       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3);
57770     } CALL_CATCH_EXCEPTION(0);
57771   }
57772   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
57773   return jresult;
57774 }
57775
57776
57777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_3(char * jarg1, void * jarg2) {
57778   void * jresult ;
57779   std::string *arg1 = 0 ;
57780   Dali::ImageDimensions arg2 ;
57781   Dali::ImageDimensions *argp2 ;
57782   Dali::Devel::PixelBuffer result;
57783
57784   if (!jarg1) {
57785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57786     return 0;
57787   }
57788   std::string arg1_str(jarg1);
57789   arg1 = &arg1_str;
57790   argp2 = (Dali::ImageDimensions *)jarg2;
57791   if (!argp2) {
57792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
57793     return 0;
57794   }
57795   arg2 = *argp2;
57796   {
57797     try {
57798       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2);
57799     } CALL_CATCH_EXCEPTION(0);
57800   }
57801   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
57802   return jresult;
57803 }
57804
57805
57806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_4(char * jarg1) {
57807   void * jresult ;
57808   std::string *arg1 = 0 ;
57809   Dali::Devel::PixelBuffer result;
57810
57811   if (!jarg1) {
57812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57813     return 0;
57814   }
57815   std::string arg1_str(jarg1);
57816   arg1 = &arg1_str;
57817   {
57818     try {
57819       result = Dali::LoadImageFromFile((std::string const &)*arg1);
57820     } CALL_CATCH_EXCEPTION(0);
57821   }
57822   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
57823   return jresult;
57824 }
57825
57826
57827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
57828   void * jresult ;
57829   std::string *arg1 = 0 ;
57830   Dali::ImageDimensions arg2 ;
57831   Dali::FittingMode::Type arg3 ;
57832   Dali::SamplingMode::Type arg4 ;
57833   bool arg5 ;
57834   Dali::ImageDimensions *argp2 ;
57835   Dali::ImageDimensions result;
57836
57837   if (!jarg1) {
57838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57839     return 0;
57840   }
57841   std::string arg1_str(jarg1);
57842   arg1 = &arg1_str;
57843   argp2 = (Dali::ImageDimensions *)jarg2;
57844   if (!argp2) {
57845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
57846     return 0;
57847   }
57848   arg2 = *argp2;
57849   arg3 = (Dali::FittingMode::Type)jarg3;
57850   arg4 = (Dali::SamplingMode::Type)jarg4;
57851   arg5 = jarg5 ? true : false;
57852   {
57853     try {
57854       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4,arg5);
57855     } CALL_CATCH_EXCEPTION(0);
57856   }
57857   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
57858   return jresult;
57859 }
57860
57861
57862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
57863   void * jresult ;
57864   std::string *arg1 = 0 ;
57865   Dali::ImageDimensions arg2 ;
57866   Dali::FittingMode::Type arg3 ;
57867   Dali::SamplingMode::Type arg4 ;
57868   Dali::ImageDimensions *argp2 ;
57869   Dali::ImageDimensions result;
57870
57871   if (!jarg1) {
57872     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57873     return 0;
57874   }
57875   std::string arg1_str(jarg1);
57876   arg1 = &arg1_str;
57877   argp2 = (Dali::ImageDimensions *)jarg2;
57878   if (!argp2) {
57879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
57880     return 0;
57881   }
57882   arg2 = *argp2;
57883   arg3 = (Dali::FittingMode::Type)jarg3;
57884   arg4 = (Dali::SamplingMode::Type)jarg4;
57885   {
57886     try {
57887       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4);
57888     } CALL_CATCH_EXCEPTION(0);
57889   }
57890   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
57891   return jresult;
57892 }
57893
57894
57895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
57896   void * jresult ;
57897   std::string *arg1 = 0 ;
57898   Dali::ImageDimensions arg2 ;
57899   Dali::FittingMode::Type arg3 ;
57900   Dali::ImageDimensions *argp2 ;
57901   Dali::ImageDimensions result;
57902
57903   if (!jarg1) {
57904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57905     return 0;
57906   }
57907   std::string arg1_str(jarg1);
57908   arg1 = &arg1_str;
57909   argp2 = (Dali::ImageDimensions *)jarg2;
57910   if (!argp2) {
57911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
57912     return 0;
57913   }
57914   arg2 = *argp2;
57915   arg3 = (Dali::FittingMode::Type)jarg3;
57916   {
57917     try {
57918       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3);
57919     } CALL_CATCH_EXCEPTION(0);
57920   }
57921   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
57922   return jresult;
57923 }
57924
57925
57926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_3(char * jarg1, void * jarg2) {
57927   void * jresult ;
57928   std::string *arg1 = 0 ;
57929   Dali::ImageDimensions arg2 ;
57930   Dali::ImageDimensions *argp2 ;
57931   Dali::ImageDimensions result;
57932
57933   if (!jarg1) {
57934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57935     return 0;
57936   }
57937   std::string arg1_str(jarg1);
57938   arg1 = &arg1_str;
57939   argp2 = (Dali::ImageDimensions *)jarg2;
57940   if (!argp2) {
57941     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
57942     return 0;
57943   }
57944   arg2 = *argp2;
57945   {
57946     try {
57947       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2);
57948     } CALL_CATCH_EXCEPTION(0);
57949   }
57950   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
57951   return jresult;
57952 }
57953
57954
57955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_4(char * jarg1) {
57956   void * jresult ;
57957   std::string *arg1 = 0 ;
57958   Dali::ImageDimensions result;
57959
57960   if (!jarg1) {
57961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57962     return 0;
57963   }
57964   std::string arg1_str(jarg1);
57965   arg1 = &arg1_str;
57966   {
57967     try {
57968       result = Dali::GetClosestImageSize((std::string const &)*arg1);
57969     } CALL_CATCH_EXCEPTION(0);
57970   }
57971   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
57972   return jresult;
57973 }
57974
57975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetOriginalImageSize(char * jarg1) {
57976   void * jresult ;
57977   std::string *arg1 = 0 ;
57978   Dali::ImageDimensions result;
57979
57980   if (!jarg1) {
57981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57982     return 0;
57983   }
57984   std::string arg1_str(jarg1);
57985   arg1 = &arg1_str;
57986   {
57987     try {
57988       result = Dali::GetOriginalImageSize((std::string const &)*arg1);
57989     } CALL_CATCH_EXCEPTION(0);
57990   }
57991   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
57992   return jresult;
57993 }
57994
57995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
57996   void * jresult ;
57997   std::string *arg1 = 0 ;
57998   Dali::ImageDimensions arg2 ;
57999   Dali::FittingMode::Type arg3 ;
58000   Dali::SamplingMode::Type arg4 ;
58001   bool arg5 ;
58002   Dali::ImageDimensions *argp2 ;
58003   Dali::Devel::PixelBuffer result;
58004
58005   if (!jarg1) {
58006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58007     return 0;
58008   }
58009   std::string arg1_str(jarg1);
58010   arg1 = &arg1_str;
58011   argp2 = (Dali::ImageDimensions *)jarg2;
58012   if (!argp2) {
58013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
58014     return 0;
58015   }
58016   arg2 = *argp2;
58017   arg3 = (Dali::FittingMode::Type)jarg3;
58018   arg4 = (Dali::SamplingMode::Type)jarg4;
58019   arg5 = jarg5 ? true : false;
58020   {
58021     try {
58022       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4,arg5);
58023     } CALL_CATCH_EXCEPTION(0);
58024   }
58025   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
58026   return jresult;
58027 }
58028
58029
58030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
58031   void * jresult ;
58032   std::string *arg1 = 0 ;
58033   Dali::ImageDimensions arg2 ;
58034   Dali::FittingMode::Type arg3 ;
58035   Dali::SamplingMode::Type arg4 ;
58036   Dali::ImageDimensions *argp2 ;
58037   Dali::Devel::PixelBuffer result;
58038
58039   if (!jarg1) {
58040     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58041     return 0;
58042   }
58043   std::string arg1_str(jarg1);
58044   arg1 = &arg1_str;
58045   argp2 = (Dali::ImageDimensions *)jarg2;
58046   if (!argp2) {
58047     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
58048     return 0;
58049   }
58050   arg2 = *argp2;
58051   arg3 = (Dali::FittingMode::Type)jarg3;
58052   arg4 = (Dali::SamplingMode::Type)jarg4;
58053   {
58054     try {
58055       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4);
58056     } CALL_CATCH_EXCEPTION(0);
58057   }
58058   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
58059   return jresult;
58060 }
58061
58062
58063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
58064   void * jresult ;
58065   std::string *arg1 = 0 ;
58066   Dali::ImageDimensions arg2 ;
58067   Dali::FittingMode::Type arg3 ;
58068   Dali::ImageDimensions *argp2 ;
58069   Dali::Devel::PixelBuffer result;
58070
58071   if (!jarg1) {
58072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58073     return 0;
58074   }
58075   std::string arg1_str(jarg1);
58076   arg1 = &arg1_str;
58077   argp2 = (Dali::ImageDimensions *)jarg2;
58078   if (!argp2) {
58079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
58080     return 0;
58081   }
58082   arg2 = *argp2;
58083   arg3 = (Dali::FittingMode::Type)jarg3;
58084   {
58085     try {
58086       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3);
58087     } CALL_CATCH_EXCEPTION(0);
58088   }
58089   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
58090   return jresult;
58091 }
58092
58093
58094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_3(char * jarg1, void * jarg2) {
58095   void * jresult ;
58096   std::string *arg1 = 0 ;
58097   Dali::ImageDimensions arg2 ;
58098   Dali::ImageDimensions *argp2 ;
58099   Dali::Devel::PixelBuffer result;
58100
58101   if (!jarg1) {
58102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58103     return 0;
58104   }
58105   std::string arg1_str(jarg1);
58106   arg1 = &arg1_str;
58107   argp2 = (Dali::ImageDimensions *)jarg2;
58108   if (!argp2) {
58109     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
58110     return 0;
58111   }
58112   arg2 = *argp2;
58113   {
58114     try {
58115       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2);
58116     } CALL_CATCH_EXCEPTION(0);
58117   }
58118   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
58119   return jresult;
58120 }
58121
58122
58123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_4(char * jarg1) {
58124   void * jresult ;
58125   std::string *arg1 = 0 ;
58126   Dali::Devel::PixelBuffer result;
58127
58128   if (!jarg1) {
58129     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58130     return 0;
58131   }
58132   std::string arg1_str(jarg1);
58133   arg1 = &arg1_str;
58134   {
58135     try {
58136       result = Dali::DownloadImageSynchronously((std::string const &)*arg1);
58137     } CALL_CATCH_EXCEPTION(0);
58138   }
58139   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
58140   return jresult;
58141 }
58142
58143
58144 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New() {
58145   void * jresult ;
58146   Dali::Toolkit::WebView result;
58147
58148   {
58149     try {
58150       result = Dali::Toolkit::WebView::New();
58151     } CALL_CATCH_EXCEPTION(0);
58152   }
58153   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
58154   return jresult;
58155 }
58156
58157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New_2(char * jarg1, char * jarg2) {
58158   void * jresult ;
58159   Dali::Toolkit::WebView result;
58160
58161   std::string *arg1;
58162   std::string *arg2;
58163
58164   if (!jarg1) {
58165     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg1 is null string", 0);
58166     return 0;
58167   }
58168   if (!jarg2) {
58169     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg2 is null string", 0);
58170     return 0;
58171   }
58172
58173   std::string jarg1_str = std::string(jarg1);
58174   std::string jarg2_str = std::string(jarg2);
58175
58176   arg1 = &jarg1_str;
58177   arg2 = &jarg2_str;
58178
58179   {
58180     try {
58181       result = Dali::Toolkit::WebView::New( (std::string const &)*arg1, (std::string const &)*arg2);
58182     } CALL_CATCH_EXCEPTION(0);
58183   }
58184   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
58185   return jresult;
58186 }
58187
58188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebView__SWIG_1(void * jarg1) {
58189   void * jresult ;
58190   Dali::Toolkit::WebView *arg1 = 0 ;
58191   Dali::Toolkit::WebView *result = 0 ;
58192
58193   arg1 = (Dali::Toolkit::WebView *)jarg1;
58194   if (!arg1) {
58195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
58196     return 0;
58197   }
58198   {
58199     try {
58200       result = (Dali::Toolkit::WebView *)new Dali::Toolkit::WebView((Dali::Toolkit::WebView const &)*arg1);
58201     } CALL_CATCH_EXCEPTION(0);
58202   }
58203   jresult = (void *)result;
58204   return jresult;
58205 }
58206
58207 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebView(void * jarg1) {
58208   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58209   arg1 = (Dali::Toolkit::WebView *)jarg1;
58210   {
58211     try {
58212       delete arg1;
58213     } CALL_CATCH_EXCEPTION();
58214   }
58215 }
58216
58217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_Assign(void * jarg1, void * jarg2) {
58218   void * jresult ;
58219   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58220   Dali::Toolkit::WebView *arg2 = 0 ;
58221   Dali::Toolkit::WebView *result = 0 ;
58222
58223   arg1 = (Dali::Toolkit::WebView *)jarg1;
58224   arg2 = (Dali::Toolkit::WebView *)jarg2;
58225   if (!arg2) {
58226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
58227     return 0;
58228   }
58229   {
58230     try {
58231       result = (Dali::Toolkit::WebView *) &(arg1)->operator =((Dali::Toolkit::WebView const &)*arg2);
58232     } CALL_CATCH_EXCEPTION(0);
58233   }
58234   jresult = (void *)result;
58235   return jresult;
58236 }
58237
58238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_DownCast(void * jarg1) {
58239   void * jresult ;
58240   Dali::BaseHandle arg1 ;
58241   Dali::BaseHandle *argp1 ;
58242   Dali::Toolkit::WebView result;
58243
58244   argp1 = (Dali::BaseHandle *)jarg1;
58245   if (!argp1) {
58246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
58247     return 0;
58248   }
58249   arg1 = *argp1;
58250   {
58251     try {
58252       result = Dali::Toolkit::WebView::DownCast(arg1);
58253     } CALL_CATCH_EXCEPTION(0);
58254   }
58255   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
58256   return jresult;
58257 }
58258
58259 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_URL_get() {
58260   return (int) Dali::Toolkit::WebView::Property::URL;
58261 }
58262
58263 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_CACHE_MODEL_get() {
58264   return (int) Dali::Toolkit::WebView::Property::CACHE_MODEL;
58265 }
58266
58267 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_COOKIE_ACCEPT_POLICY_get() {
58268   return (int) Dali::Toolkit::WebView::Property::COOKIE_ACCEPT_POLICY;
58269 }
58270
58271 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_USER_AGENT_get() {
58272   return (int) Dali::Toolkit::WebView::Property::USER_AGENT;
58273 }
58274
58275 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_ENABLE_JAVASCRIPT_get() {
58276   return (int) Dali::Toolkit::WebView::Property::ENABLE_JAVASCRIPT;
58277 }
58278
58279 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_LOAD_IMAGES_AUTOMATICALLY_get() {
58280   return (int) Dali::Toolkit::WebView::Property::LOAD_IMAGES_AUTOMATICALLY;
58281 }
58282
58283 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_DEFAULT_TEXT_ENCODING_NAME_get() {
58284   return (int) Dali::Toolkit::WebView::Property::DEFAULT_TEXT_ENCODING_NAME;
58285 }
58286
58287 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_DEFAULT_FONT_SIZE_get() {
58288   return (int) Dali::Toolkit::WebView::Property::DEFAULT_FONT_SIZE;
58289 }
58290
58291 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadUrl(void * jarg1, char * jarg2) {
58292   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58293   std::string *arg2;
58294
58295   arg1 = (Dali::Toolkit::WebView *)jarg1;
58296
58297   if (!jarg2) {
58298     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58299     return;
58300   }
58301
58302   std::string jarg2str = std::string(jarg2);
58303   arg2 = &jarg2str;
58304   {
58305     try {
58306       (arg1)->LoadUrl((std::string const &)*arg2);
58307     } CALL_CATCH_EXCEPTION();
58308   }
58309 }
58310
58311 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadHTMLString(void * jarg1, char * jarg2) {
58312   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58313   std::string *arg2;
58314
58315   arg1 = (Dali::Toolkit::WebView *)jarg1;
58316   if (!jarg2) {
58317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58318     return;
58319   }
58320   std::string jarg2str = std::string(jarg2);
58321   arg2 = &jarg2str;
58322   {
58323     try {
58324       (arg1)->LoadHTMLString((std::string const &)*arg2);
58325     } CALL_CATCH_EXCEPTION();
58326   }
58327 }
58328
58329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Reload(void * jarg1) {
58330   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58331
58332   arg1 = (Dali::Toolkit::WebView *)jarg1;
58333   {
58334     try {
58335       (arg1)->Reload();
58336     } CALL_CATCH_EXCEPTION();
58337   }
58338 }
58339
58340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_StopLoading(void * jarg1) {
58341   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58342
58343   arg1 = (Dali::Toolkit::WebView *)jarg1;
58344   {
58345     try {
58346       (arg1)->StopLoading();
58347     } CALL_CATCH_EXCEPTION();
58348   }
58349 }
58350
58351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Suspend(void * jarg1) {
58352   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58353
58354   arg1 = (Dali::Toolkit::WebView *)jarg1;
58355   {
58356     try {
58357       (arg1)->Suspend();
58358     } CALL_CATCH_EXCEPTION();
58359   }
58360 }
58361
58362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Resume(void * jarg1) {
58363   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58364
58365   arg1 = (Dali::Toolkit::WebView *)jarg1;
58366   {
58367     try {
58368       (arg1)->Resume();
58369     } CALL_CATCH_EXCEPTION();
58370   }
58371 }
58372
58373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoBack(void * jarg1) {
58374   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58375
58376   arg1 = (Dali::Toolkit::WebView *)jarg1;
58377   {
58378     try {
58379       (arg1)->GoBack();
58380     } CALL_CATCH_EXCEPTION();
58381   }
58382 }
58383
58384 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoForward(void * jarg1) {
58385   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58386
58387   arg1 = (Dali::Toolkit::WebView *)jarg1;
58388   {
58389     try {
58390       (arg1)->GoForward();
58391     } CALL_CATCH_EXCEPTION();
58392   }
58393 }
58394
58395 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoBack(void * jarg1) {
58396   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58397   bool ret;
58398
58399   arg1 = (Dali::Toolkit::WebView *)jarg1;
58400   {
58401     try {
58402       ret = (arg1)->CanGoBack();
58403     } CALL_CATCH_EXCEPTION(0);
58404   }
58405   return ret;
58406 }
58407
58408 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoForward(void * jarg1) {
58409   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58410   bool ret;
58411
58412   arg1 = (Dali::Toolkit::WebView *)jarg1;
58413   {
58414     try {
58415       ret = (arg1)->CanGoForward();
58416     } CALL_CATCH_EXCEPTION(0);
58417   }
58418   return ret;
58419 }
58420
58421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_EvaluateJavaScript(void * jarg1, char * jarg2, void* jarg3) {
58422   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58423   std::string *arg2;
58424
58425   arg1 = (Dali::Toolkit::WebView *)jarg1;
58426   if (!jarg2) {
58427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58428     return;
58429   }
58430   std::string jarg2_str = std::string(jarg2);
58431   arg2 = &jarg2_str;
58432
58433   {
58434     try {
58435       if (jarg3) {
58436         void (*handler)(char*) = (void (*)(char*)) jarg3;
58437         (arg1)->EvaluateJavaScript((std::string const &)*arg2, [handler](const std::string& result) {
58438           handler(SWIG_csharp_string_callback(result.c_str()));
58439         });
58440       } else {
58441         (arg1)->EvaluateJavaScript((std::string const &)*arg2);
58442       }
58443     } CALL_CATCH_EXCEPTION();
58444   }
58445 }
58446
58447 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_AddJavaScriptMessageHandler(void* jarg1, char* jarg2, void* jarg3)
58448 {
58449   if (!jarg2) {
58450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58451     return;
58452   }
58453
58454   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
58455   std::string exposedObjectName = jarg2;
58456   void (*handler)(char*) = (void (*)(char*)) jarg3;
58457
58458   {
58459     try {
58460       webview->AddJavaScriptMessageHandler(exposedObjectName, [handler](const std::string& message) {
58461         handler(SWIG_csharp_string_callback(message.c_str()));
58462       });
58463     } CALL_CATCH_EXCEPTION();
58464   }
58465 }
58466
58467 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearHistory(void * jarg1) {
58468   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58469
58470   arg1 = (Dali::Toolkit::WebView *)jarg1;
58471   {
58472     try {
58473       (arg1)->ClearHistory();
58474     } CALL_CATCH_EXCEPTION();
58475   }
58476 }
58477
58478 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearCache(void * jarg1) {
58479   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58480
58481   arg1 = (Dali::Toolkit::WebView *)jarg1;
58482   {
58483     try {
58484       (arg1)->ClearCache();
58485     } CALL_CATCH_EXCEPTION();
58486   }
58487 }
58488
58489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearCookies(void * jarg1) {
58490   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
58491
58492   arg1 = (Dali::Toolkit::WebView *)jarg1;
58493   {
58494     try {
58495       (arg1)->ClearCookies();
58496     } CALL_CATCH_EXCEPTION();
58497   }
58498 }
58499
58500 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_WebView_SWIGUpcast(Dali::Toolkit::WebView *jarg1) {
58501     return (Dali::Toolkit::Control *)jarg1;
58502 }
58503
58504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadSignal_PageLoadStarted(void * jarg1) {
58505   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
58506   SignalConverter::WebViewPageLoadSignal* result = NULL;
58507   {
58508     try {
58509       result = new SignalConverter::WebViewPageLoadSignal(&webview->PageLoadStartedSignal());
58510     } CALL_CATCH_EXCEPTION(0);
58511   }
58512   return (void*) result;
58513 }
58514
58515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadSignal_PageLoadFinished(void * jarg1) {
58516   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
58517   SignalConverter::WebViewPageLoadSignal* result = NULL;
58518   {
58519     try {
58520       result = new SignalConverter::WebViewPageLoadSignal(&webview->PageLoadFinishedSignal());
58521     } CALL_CATCH_EXCEPTION(0);
58522   }
58523   return (void*) result;
58524 }
58525
58526 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewPageLoadSignal(void * jarg1)
58527 {
58528   SignalConverter::WebViewPageLoadSignal* object = (SignalConverter::WebViewPageLoadSignal*) jarg1;
58529   {
58530     try {
58531       delete object;
58532     } CALL_CATCH_EXCEPTION();
58533   }
58534 }
58535
58536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadSignal_Connect(void * jarg1, void * jarg2)
58537 {
58538   SignalConverter::WebViewPageLoadSignal* proxy = (SignalConverter::WebViewPageLoadSignal*) jarg1;
58539   SignalConverter::WebViewPageLoadSignal::CallbackType callback = (SignalConverter::WebViewPageLoadSignal::CallbackType) jarg2;
58540   {
58541     try {
58542       proxy->Connect(callback);
58543     } CALL_CATCH_EXCEPTION();
58544   }
58545 }
58546
58547
58548 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadSignal_Disconnect(void * jarg1, void * jarg2) {
58549   SignalConverter::WebViewPageLoadSignal* proxy = (SignalConverter::WebViewPageLoadSignal*) jarg1;
58550   SignalConverter::WebViewPageLoadSignal::CallbackType callback = (SignalConverter::WebViewPageLoadSignal::CallbackType) jarg2;
58551   {
58552     try {
58553       proxy->Disconnect(callback);
58554     } CALL_CATCH_EXCEPTION();
58555   }
58556 }
58557
58558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadErrorSignal_PageLoadError(void * jarg1) {
58559   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
58560   SignalConverter::WebViewPageLoadErrorSignal* result = NULL;
58561   {
58562     try {
58563       result = new SignalConverter::WebViewPageLoadErrorSignal(&webview->PageLoadErrorSignal());
58564     } CALL_CATCH_EXCEPTION(0);
58565   }
58566   return (void*) result;
58567 }
58568
58569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewPageLoadErrorSignal(void * jarg1)
58570 {
58571   SignalConverter::WebViewPageLoadErrorSignal* object = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
58572   {
58573     try {
58574       delete object;
58575     } CALL_CATCH_EXCEPTION();
58576   }
58577 }
58578
58579 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadErrorSignal_Connect(void * jarg1, void * jarg2)
58580 {
58581   SignalConverter::WebViewPageLoadErrorSignal* proxy = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
58582   SignalConverter::WebViewPageLoadErrorSignal::CallbackType callback = (SignalConverter::WebViewPageLoadErrorSignal::CallbackType) jarg2;
58583   {
58584     try {
58585       proxy->Connect(callback);
58586     } CALL_CATCH_EXCEPTION();
58587   }
58588 }
58589
58590
58591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadErrorSignal_Disconnect(void * jarg1, void * jarg2) {
58592   SignalConverter::WebViewPageLoadErrorSignal* proxy = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
58593   SignalConverter::WebViewPageLoadErrorSignal::CallbackType callback = (SignalConverter::WebViewPageLoadErrorSignal::CallbackType) jarg2;
58594   {
58595     try {
58596       proxy->Disconnect(callback);
58597     } CALL_CATCH_EXCEPTION();
58598   }
58599 }
58600
58601 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetEnvironmentVariable(char * jarg1) {
58602   const char * result = EnvironmentVariable::GetEnvironmentVariable(jarg1);
58603   char * jresult = SWIG_csharp_string_callback((const char *)result);
58604   return jresult;
58605 }
58606
58607 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_SetEnvironmentVariable(char * jarg1, char * jarg2) {
58608   bool result = EnvironmentVariable::SetEnvironmentVariable(jarg1, jarg2);
58609   return result;
58610 }
58611
58612
58613 struct NativeImageSourcePtrHandle
58614 {
58615   NativeImageSourcePtr Ptr;
58616 };
58617
58618 SWIGEXPORT NativeImageInterface* SWIGSTDCALL CSharp_Dali_NativeImageSource_Upcast(void* jarg1)
58619 {
58620   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
58621   return (NativeImageInterface*)(arg1);
58622 }
58623
58624 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_New_Handle(unsigned int jarg1, unsigned int jarg2, int jarg3)
58625 {
58626   void* jresult;
58627   NativeImageSourcePtrHandle* handle = new NativeImageSourcePtrHandle();
58628   {
58629     try {
58630       handle->Ptr = ( NativeImageSource::New(jarg1, jarg2, (NativeImageSource::ColorDepth)jarg3) );
58631     }
58632     catch (std::out_of_range & e) {
58633       {
58634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58635       };
58636     }
58637     catch (std::exception & e) {
58638       {
58639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58640       };
58641     }
58642     catch (Dali::DaliException e) {
58643       {
58644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58645       };
58646     }
58647     catch (...) {
58648       {
58649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58650       };
58651     }
58652   }
58653   jresult = (void *)handle;
58654   return jresult;
58655 }
58656
58657 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_New(void* jarg1)
58658 {
58659   void* jresult;
58660   NativeImageSourcePtrHandle* handle = (NativeImageSourcePtrHandle*)jarg1;
58661   jresult = (void*)( handle->Ptr.Get() );
58662   return jresult;
58663 }
58664
58665 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageSource_Delete(void* jarg1) {
58666   NativeImageSourcePtrHandle* arg1 = (NativeImageSourcePtrHandle*)jarg1;
58667   {
58668     try {
58669       delete arg1;
58670     }
58671     catch (std::out_of_range & e) {
58672       {
58673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
58674       };
58675     }
58676     catch (std::exception & e) {
58677       {
58678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
58679       };
58680     }
58681     catch (Dali::DaliException e) {
58682       {
58683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return;
58684       };
58685     }
58686     catch (...) {
58687       {
58688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return;
58689       };
58690     }
58691   }
58692 }
58693
58694 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_AcquireBuffer(void* jarg1, int* jarg2, int* jarg3, int* jarg4)
58695 {
58696   void* jresult;
58697   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
58698   uint16_t* arg2 = (uint16_t*)(jarg2);
58699   uint16_t* arg3 = (uint16_t*)(jarg3);
58700   uint16_t* arg4 = (uint16_t*)(jarg4);
58701   {
58702     try {
58703       jresult = (void *)Dali::DevelNativeImageSource::AcquireBuffer( *arg1, *arg2, *arg3, *arg4 );
58704     }
58705     catch (std::out_of_range & e) {
58706       {
58707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58708       };
58709     }
58710     catch (std::exception & e) {
58711       {
58712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58713       };
58714     }
58715     catch (Dali::DaliException e) {
58716       {
58717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58718       };
58719     }
58720     catch (...) {
58721       {
58722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58723       };
58724     }
58725   }
58726   return jresult;
58727 }
58728
58729 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NativeImageSource_ReleaseBuffer(void* jarg1)
58730 {
58731   bool jresult;
58732   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
58733
58734   {
58735     try {
58736       jresult = Dali::DevelNativeImageSource::ReleaseBuffer( *arg1 );
58737     }
58738     catch (std::out_of_range & e) {
58739       {
58740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58741       };
58742     }
58743     catch (std::exception & e) {
58744       {
58745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58746       };
58747     }
58748     catch (Dali::DaliException e) {
58749       {
58750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58751       };
58752     }
58753     catch (...) {
58754       {
58755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58756       };
58757     }
58758   }
58759   return jresult;
58760 }
58761
58762
58763 #ifdef __cplusplus
58764 }
58765 #endif